001 /*
002 * Copyright 2007-2014 UnboundID Corp.
003 * All Rights Reserved.
004 */
005 /*
006 * Copyright (C) 2008-2014 UnboundID Corp.
007 *
008 * This program is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License (GPLv2 only)
010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011 * as published by the Free Software Foundation.
012 *
013 * This program is distributed in the hope that it will be useful,
014 * but WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016 * GNU General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with this program; if not, see <http://www.gnu.org/licenses>.
020 */
021 package com.unboundid.ldap.sdk;
022
023
024
025 import com.unboundid.util.Mutable;
026 import com.unboundid.util.StaticUtils;
027 import com.unboundid.util.ThreadSafety;
028 import com.unboundid.util.ThreadSafetyLevel;
029 import com.unboundid.util.ssl.SSLSocketVerifier;
030 import com.unboundid.util.ssl.TrustAllSSLSocketVerifier;
031
032 import static com.unboundid.util.Validator.*;
033
034
035
036 /**
037 * This class provides a data structure that may be used to configure a number
038 * of connection-related properties. Elements included in the set of connection
039 * options include:
040 * <UL>
041 * <LI>A flag that indicates whether the SDK should attempt to automatically
042 * re-establish a connection if it is unexpectedly closed. By default,
043 * it will not attempt to do so.</LI>
044 * <LI>A flag that indicates whether simple bind attempts that contain a
045 * non-empty DN will be required to have a non-empty password. By
046 * default, a password will be required in such cases.</LI>
047 * <LI>A flag that indicates whether to automatically attempt to follow any
048 * referrals that may be returned by the server. By default, it will not
049 * automatically attempt to follow referrals.</LI>
050 * <LI>A referral hop limit, which indicates the maximum number of hops that
051 * the connection may take when trying to follow a referral. The default
052 * referral hop limit is five.</LI>
053 * <LI>The referral connector that should be used to create and optionally
054 * authenticate connections used to follow referrals encountered during
055 * processing. By default, referral connections will use the same socket
056 * factory and bind request as the client connection on which the referral
057 * was received.</LI>
058 * <LI>A flag that indicates whether to use the SO_KEEPALIVE socket option to
059 * attempt to more quickly detect when idle TCP connections have been lost
060 * or to prevent them from being unexpectedly closed by intermediate
061 * network hardware. By default, the SO_KEEPALIVE socket option will be
062 * used.</LI>
063 * <LI>A flag that indicates whether to use the SO_LINGER socket option to
064 * indicate how long a connection should linger after it has been closed,
065 * and a value that specifies the length of time that it should linger.
066 * By default, the SO_LINGER option will be used with a timeout of 5
067 * seconds.</LI>
068 * <LI>A flag that indicates whether to use the SO_REUSEADDR socket option to
069 * indicate that a socket in a TIME_WAIT state may be reused. By default,
070 * the SO_REUSEADDR socket option will be used.</LI>
071 * <LI>A flag that indicates whether to operate in synchronous mode, in which
072 * connections may exhibit better performance and will not require a
073 * separate reader thread, but will not allow multiple concurrent
074 * operations to be used on the same connection.</LI>
075 * <LI>A flag that indicates whether to use the TCP_NODELAY socket option to
076 * indicate that any data written to the socket will be sent immediately
077 * rather than delaying for a short amount of time to see if any more data
078 * is to be sent that could potentially be included in the same packet.
079 * By default, the TCP_NODELAY socket option will be used.</LI>
080 * <LI>A value which specifies the maximum length of time in milliseconds that
081 * an attempt to establish a connection should be allowed to block before
082 * failing. By default, a timeout of 60,000 milliseconds (1 minute) will
083 * be used.</LI>
084 * <LI>A value which specifies the default timeout in milliseconds that the
085 * SDK should wait for a response from the server before failing. By
086 * default, a timeout of 300,000 milliseconds (5 minutes) will be
087 * used.</LI>
088 * <LI>A flag that indicates whether to attempt to abandon any request for
089 * which no response is received after waiting for the maximum response
090 * timeout. By default, no abandon request will be sent.</LI>
091 * <LI>A value which specifies the largest LDAP message size that the SDK will
092 * be willing to read from the directory server. By default, the SDK will
093 * not allow responses larger than 20971520 bytes (20MB). If it
094 * encounters a message that may be larger than the maximum allowed
095 * message size, then the SDK will terminate the connection to the
096 * server.</LI>
097 * <LI>The {@link DisconnectHandler} that should be used to receive
098 * notification if connection is disconnected for any reason. By default,
099 * no {@code DisconnectHandler} will be used.</LI>
100 * <LI>The {@link UnsolicitedNotificationHandler} that should be used to
101 * receive notification about any unsolicited notifications returned by
102 * the server. By default, no {@code UnsolicitedNotificationHandler} will
103 * be used.</LI>
104 * <LI>A flag that indicates whether to capture a thread stack trace whenever
105 * a new connection is established. Capturing a thread stack trace when
106 * establishing a connection may be marginally expensive, but can be
107 * useful for debugging certain kinds of problems like leaked connections
108 * (connections that are established but never explicitly closed). By
109 * default, connect stack traces will not be captured.</LI>
110 * <LI>A flag that indicates whether connections should try to retrieve schema
111 * information from the server, which may be used to better determine
112 * which matching rules should be used when comparing attribute values.
113 * By default, server schema information will not be retrieved.</LI>
114 * <LI>The size of the socket receive buffer, which may be used for
115 * temporarily holding data received from the directory server until it
116 * can be read and processed by the LDAP SDK. By default, the receive
117 * buffer size will be automatically determined by the JVM based on the
118 * underlying system settings.</LI>
119 * <LI>The size of the socket send buffer, which may be used for temporarily
120 * holding data to be sent to the directory server until it can actually
121 * be transmitted over the network. By default, the send buffer size will
122 * be automatically determined by the JVM based on the underlying system
123 * settings.</LI>
124 * <LI>A flag which indicates whether to allow a single socket factory instance
125 * (which may be shared across multiple connections) to be used to create
126 * multiple concurrent connections. This offers better and more
127 * predictable performance on some JVM implementations (especially when
128 * connection attempts fail as a result of a connection timeout), but some
129 * JVMs are known to use non-threadsafe socket factory implementations and
130 * may fail from concurrent use (for example, at least some IBM JVMs
131 * exhibit this behavior). By default, Sun/Oracle JVMs will allow
132 * concurrent socket factory use, but JVMs from other vendors will use
133 * synchronization to ensure that a socket factory will only be allowed to
134 * create one connection at a time.</LI>
135 * <LI>A class that may be used to perform additional verification (e.g.,
136 * hostname validation) for any {@code SSLSocket} instances created. By
137 * default, no special verification will be performed.</LI>
138 * </UL>
139 */
140 @Mutable()
141 @ThreadSafety(level=ThreadSafetyLevel.NOT_THREADSAFE)
142 public final class LDAPConnectionOptions
143 {
144 /**
145 * The default value ({@code false}) for the setting that controls whether to
146 * attempt to abandon any request for which no response is received within the
147 * maximum response timeout.
148 */
149 static final boolean DEFAULT_ABANDON_ON_TIMEOUT = false;
150
151
152
153 /**
154 * The default value ({@code false}) for the setting that controls whether to
155 * automatically attempt to reconnect if a connection is unexpectedly lost.
156 */
157 static final boolean DEFAULT_AUTO_RECONNECT = false;
158
159
160
161 /**
162 * The default value ({@code true}) for the setting that controls whether
163 * simple bind requests with a DN are also required to contain a password.
164 */
165 static final boolean DEFAULT_BIND_WITH_DN_REQUIRES_PASSWORD = true;
166
167
168
169 /**
170 * The default value ({@code false}) for the setting that controls whether to
171 * capture a thread stack trace whenever an attempt is made to establish a
172 * connection.
173 */
174 static final boolean DEFAULT_CAPTURE_CONNECT_STACK_TRACE = false;
175
176
177
178 /**
179 * The default value ({@code false}) for the setting that controls whether to
180 * attempt to automatically follow referrals.
181 */
182 static final boolean DEFAULT_FOLLOW_REFERRALS = false;
183
184
185
186 /**
187 * The default value ({@code false}) for the setting that controls whether all
188 * connections in a connection pool should use the same cached schema object.
189 */
190 static final boolean DEFAULT_USE_POOLED_SCHEMA = false;
191
192
193
194 /**
195 * The default value ({@code true}) for the setting that controls whether to
196 * use the {@code SO_KEEPALIVE} socket option.
197 */
198 static final boolean DEFAULT_USE_KEEPALIVE = true;
199
200
201
202 /**
203 * The default value ({@code true}) for the setting that controls whether to
204 * use the {@code SO_LINGER} socket option.
205 */
206 static final boolean DEFAULT_USE_LINGER = true;
207
208
209
210 /**
211 * The default value ({@code true}) for the setting that controls whether to
212 * use the {@code SO_REUSEADDR} socket option.
213 */
214 static final boolean DEFAULT_USE_REUSE_ADDRESS = true;
215
216
217
218 /**
219 * The default value ({@code false}) for the setting that controls whether to
220 * use schema when reading data from the server.
221 */
222 static final boolean DEFAULT_USE_SCHEMA = false;
223
224
225
226 /**
227 * The default value ({@code false}) for the setting that controls whether to
228 * operate in synchronous mode, in which only a single outstanding operation
229 * may be in progress on an associated connection at any given time.
230 */
231 static final boolean DEFAULT_USE_SYNCHRONOUS_MODE = false;
232
233
234
235 /**
236 * The default value ({@code true}) for the setting that controls whether to
237 * use the {@code TCP_NODELAY} socket option.
238 */
239 static final boolean DEFAULT_USE_TCP_NODELAY = true;
240
241
242
243 /**
244 * The default value (60000) for the setting that controls the timeout in
245 * milliseconds when trying to establish a new connection.
246 */
247 static final int DEFAULT_CONNECT_TIMEOUT_MILLIS = 60000;
248
249
250
251 /**
252 * The default value (5) for the setting that controls the timeout in seconds
253 * that will be used with the {@code SO_LINGER} socket option.
254 */
255 static final int DEFAULT_LINGER_TIMEOUT_SECONDS = 5;
256
257
258
259 /**
260 * The default value (20971520 bytes, or 20MB) for the setting that controls
261 * the maximum LDAP message size in bytes that will be allowed when reading
262 * data from a directory server.
263 */
264 static final int DEFAULT_MAX_MESSAGE_SIZE = 20971520;
265
266
267
268 /**
269 * The default size to use for the receive buffer.
270 */
271 static final int DEFAULT_RECEIVE_BUFFER_SIZE = 0;
272
273
274
275 /**
276 * The default value (5) for the setting that controls the referral hop limit.
277 */
278 static final int DEFAULT_REFERRAL_HOP_LIMIT = 5;
279
280
281
282 /**
283 * The default size to use for the send buffer.
284 */
285 static final int DEFAULT_SEND_BUFFER_SIZE = 0;
286
287
288
289 /**
290 * The default value (3600000 milliseconds, or one hour) for the setting that
291 * controls the default pooled schema timeout.
292 */
293 static final long DEFAULT_POOLED_SCHEMA_TIMEOUT_MILLIS = 3600000L;
294
295
296
297 /**
298 * The default value (300000) for the setting that controls the default
299 * response timeout in milliseconds.
300 */
301 static final long DEFAULT_RESPONSE_TIMEOUT_MILLIS = 300000L;
302
303
304
305 /**
306 * The default value for the setting that controls the default behavior with
307 * regard to whether to allow concurrent use of a socket factory to create
308 * client connections.
309 */
310 static final boolean DEFAULT_ALLOW_CONCURRENT_SOCKET_FACTORY_USE;
311 static
312 {
313 final String vmVendor =
314 StaticUtils.toLowerCase(System.getProperty("java.vm.vendor"));
315 DEFAULT_ALLOW_CONCURRENT_SOCKET_FACTORY_USE = ((vmVendor != null) &&
316 (vmVendor.contains("sun microsystems") ||
317 vmVendor.contains("oracle") ||
318 vmVendor.contains("apple")));
319 }
320
321
322
323 /**
324 * The default {@code SSLSocketVerifier} instance that will be used for
325 * performing extra validation for {@code SSLSocket} instances.
326 */
327 static final SSLSocketVerifier DEFAULT_SSL_SOCKET_VERIFIER =
328 TrustAllSSLSocketVerifier.getInstance();
329
330
331
332 // Indicates whether to send an abandon request for any operation for which no
333 // response is received in the maximum response timeout.
334 private boolean abandonOnTimeout;
335
336 // Indicates whether to use synchronization prevent concurrent use of the
337 // socket factory instance associated with a connection or set of connections.
338 private boolean allowConcurrentSocketFactoryUse;
339
340 // Indicates whether the connection should attempt to automatically reconnect
341 // if the connection to the server is lost.
342 private boolean autoReconnect;
343
344 // Indicates whether to allow simple binds that contain a DN but no password.
345 private boolean bindWithDNRequiresPassword;
346
347 // Indicates whether to capture a thread stack trace whenever an attempt is
348 // made to establish a connection;
349 private boolean captureConnectStackTrace;
350
351 // Indicates whether to attempt to follow any referrals that are encountered.
352 private boolean followReferrals;
353
354 // Indicates whether to use SO_KEEPALIVE for the underlying sockets.
355 private boolean useKeepAlive;
356
357 // Indicates whether to use SO_LINGER for the underlying sockets.
358 private boolean useLinger;
359
360 // Indicates whether to use SO_REUSEADDR for the underlying sockets.
361 private boolean useReuseAddress;
362
363 // Indicates whether all connections in a connection pool should reference
364 // the same schema.
365 private boolean usePooledSchema;
366
367 // Indicates whether to try to use schema information when reading data from
368 // the server.
369 private boolean useSchema;
370
371 // Indicates whether to use synchronous mode in which only a single operation
372 // may be in progress on associated connections at any given time.
373 private boolean useSynchronousMode;
374
375 // Indicates whether to use TCP_NODELAY for the underlying sockets.
376 private boolean useTCPNoDelay;
377
378 // The disconnect handler for associated connections.
379 private DisconnectHandler disconnectHandler;
380
381 // The connect timeout, in milliseconds.
382 private int connectTimeout;
383
384 // The linger timeout to use if SO_LINGER is to be used.
385 private int lingerTimeout;
386
387 // The maximum message size in bytes that will be allowed when reading data
388 // from a directory server.
389 private int maxMessageSize;
390
391 // The socket receive buffer size to request.
392 private int receiveBufferSize;
393
394 // The referral hop limit to use if referral following is enabled.
395 private int referralHopLimit;
396
397 // The socket send buffer size to request.
398 private int sendBufferSize;
399
400 // The pooled schema timeout, in milliseconds.
401 private long pooledSchemaTimeout;
402
403 // The response timeout, in milliseconds.
404 private long responseTimeout;
405
406 // Tne default referral connector that should be used for associated
407 // connections.
408 private ReferralConnector referralConnector;
409
410 // The SSLSocketVerifier instance to use to perform extra validation on
411 // newly-established SSLSocket instances.
412 private SSLSocketVerifier sslSocketVerifier;
413
414 // The unsolicited notification handler for associated connections.
415 private UnsolicitedNotificationHandler unsolicitedNotificationHandler;
416
417
418
419 /**
420 * Creates a new set of LDAP connection options with the default settings.
421 */
422 public LDAPConnectionOptions()
423 {
424 abandonOnTimeout = DEFAULT_ABANDON_ON_TIMEOUT;
425 autoReconnect = DEFAULT_AUTO_RECONNECT;
426 bindWithDNRequiresPassword = DEFAULT_BIND_WITH_DN_REQUIRES_PASSWORD;
427 captureConnectStackTrace = DEFAULT_CAPTURE_CONNECT_STACK_TRACE;
428 followReferrals = DEFAULT_FOLLOW_REFERRALS;
429 useKeepAlive = DEFAULT_USE_KEEPALIVE;
430 useLinger = DEFAULT_USE_LINGER;
431 useReuseAddress = DEFAULT_USE_REUSE_ADDRESS;
432 usePooledSchema = DEFAULT_USE_POOLED_SCHEMA;
433 useSchema = DEFAULT_USE_SCHEMA;
434 useSynchronousMode = DEFAULT_USE_SYNCHRONOUS_MODE;
435 useTCPNoDelay = DEFAULT_USE_TCP_NODELAY;
436 connectTimeout = DEFAULT_CONNECT_TIMEOUT_MILLIS;
437 lingerTimeout = DEFAULT_LINGER_TIMEOUT_SECONDS;
438 maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE;
439 referralHopLimit = DEFAULT_REFERRAL_HOP_LIMIT;
440 pooledSchemaTimeout = DEFAULT_POOLED_SCHEMA_TIMEOUT_MILLIS;
441 responseTimeout = DEFAULT_RESPONSE_TIMEOUT_MILLIS;
442 receiveBufferSize = DEFAULT_RECEIVE_BUFFER_SIZE;
443 sendBufferSize = DEFAULT_SEND_BUFFER_SIZE;
444 disconnectHandler = null;
445 referralConnector = null;
446 sslSocketVerifier = DEFAULT_SSL_SOCKET_VERIFIER;
447 unsolicitedNotificationHandler = null;
448
449 allowConcurrentSocketFactoryUse =
450 DEFAULT_ALLOW_CONCURRENT_SOCKET_FACTORY_USE;
451 }
452
453
454
455 /**
456 * Returns a duplicate of this LDAP connection options object that may be
457 * modified without impacting this instance.
458 *
459 * @return A duplicate of this LDAP connection options object that may be
460 * modified without impacting this instance.
461 */
462 public LDAPConnectionOptions duplicate()
463 {
464 final LDAPConnectionOptions o = new LDAPConnectionOptions();
465
466 o.abandonOnTimeout = abandonOnTimeout;
467 o.allowConcurrentSocketFactoryUse = allowConcurrentSocketFactoryUse;
468 o.autoReconnect = autoReconnect;
469 o.bindWithDNRequiresPassword = bindWithDNRequiresPassword;
470 o.captureConnectStackTrace = captureConnectStackTrace;
471 o.followReferrals = followReferrals;
472 o.useKeepAlive = useKeepAlive;
473 o.useLinger = useLinger;
474 o.useReuseAddress = useReuseAddress;
475 o.usePooledSchema = usePooledSchema;
476 o.useSchema = useSchema;
477 o.useSynchronousMode = useSynchronousMode;
478 o.useTCPNoDelay = useTCPNoDelay;
479 o.connectTimeout = connectTimeout;
480 o.lingerTimeout = lingerTimeout;
481 o.maxMessageSize = maxMessageSize;
482 o.pooledSchemaTimeout = pooledSchemaTimeout;
483 o.responseTimeout = responseTimeout;
484 o.referralConnector = referralConnector;
485 o.referralHopLimit = referralHopLimit;
486 o.disconnectHandler = disconnectHandler;
487 o.unsolicitedNotificationHandler = unsolicitedNotificationHandler;
488 o.receiveBufferSize = receiveBufferSize;
489 o.sendBufferSize = sendBufferSize;
490 o.sslSocketVerifier = sslSocketVerifier;
491
492 return o;
493 }
494
495
496
497 /**
498 * Indicates whether associated connections should attempt to automatically
499 * reconnect to the target server if the connection is lost. Note that this
500 * option will not have any effect on pooled connections because defunct
501 * pooled connections will be replaced by newly-created connections rather
502 * than attempting to re-establish the existing connection.
503 *
504 * @return {@code true} if associated connections should attempt to
505 * automatically reconnect to the target server if the connection is
506 * lost, or {@code false} if not.
507 */
508 public boolean autoReconnect()
509 {
510 return autoReconnect;
511 }
512
513
514
515 /**
516 * Specifies whether associated connections should attempt to automatically
517 * reconnect to the target server if the connection is lost. Note that
518 * automatic reconnection will only be available for authenticated clients if
519 * the authentication mechanism used provides support for re-binding on a new
520 * connection. Also note that this option will not have any effect on pooled
521 * connections because defunct pooled connections will be replaced by
522 * newly-created connections rather than attempting to re-establish the
523 * existing connection. Further, auto-reconnect should not be used with
524 * connections that use StartTLS or some other mechanism to alter the state
525 * of the connection beyond authentication.
526 *
527 * @param autoReconnect Specifies whether associated connections should
528 * attempt to automatically reconnect to the target
529 * server if the connection is lost.
530 */
531 public void setAutoReconnect(final boolean autoReconnect)
532 {
533 this.autoReconnect = autoReconnect;
534 }
535
536
537
538 /**
539 * Indicates whether the SDK should allow simple bind operations that contain
540 * a bind DN but no password. Binds of this type may represent a security
541 * vulnerability in client applications because they may cause the client to
542 * believe that the user is properly authenticated when the server considers
543 * it to be an unauthenticated connection.
544 *
545 * @return {@code true} if the SDK should allow simple bind operations that
546 * contain a bind DN but no password, or {@code false} if not.
547 */
548 public boolean bindWithDNRequiresPassword()
549 {
550 return bindWithDNRequiresPassword;
551 }
552
553
554
555 /**
556 * Specifies whether the SDK should allow simple bind operations that contain
557 * a bind DN but no password.
558 *
559 * @param bindWithDNRequiresPassword Indicates whether the SDK should allow
560 * simple bind operations that contain a
561 * bind DN but no password.
562 */
563 public void setBindWithDNRequiresPassword(
564 final boolean bindWithDNRequiresPassword)
565 {
566 this.bindWithDNRequiresPassword = bindWithDNRequiresPassword;
567 }
568
569
570
571 /**
572 * Indicates whether the LDAP SDK should capture a thread stack trace for each
573 * attempt made to establish a connection. If this is enabled, then the
574 * {@link LDAPConnection#getConnectStackTrace()} method may be used to
575 * retrieve the stack trace.
576 *
577 * @return {@code true} if a thread stack trace should be captured whenever a
578 * connection is established, or {@code false} if not.
579 */
580 public boolean captureConnectStackTrace()
581 {
582 return captureConnectStackTrace;
583 }
584
585
586
587 /**
588 * Specifies whether the LDAP SDK should capture a thread stack trace for each
589 * attempt made to establish a connection.
590 *
591 * @param captureConnectStackTrace Indicates whether to capture a thread
592 * stack trace for each attempt made to
593 * establish a connection.
594 */
595 public void setCaptureConnectStackTrace(
596 final boolean captureConnectStackTrace)
597 {
598 this.captureConnectStackTrace = captureConnectStackTrace;
599 }
600
601
602
603 /**
604 * Retrieves the maximum length of time in milliseconds that a connection
605 * attempt should be allowed to continue before giving up.
606 *
607 * @return The maximum length of time in milliseconds that a connection
608 * attempt should be allowed to continue before giving up, or zero
609 * to indicate that there should be no connect timeout.
610 */
611 public int getConnectTimeoutMillis()
612 {
613 return connectTimeout;
614 }
615
616
617
618 /**
619 * Specifies the maximum length of time in milliseconds that a connection
620 * attempt should be allowed to continue before giving up. A value of zero
621 * indicates that there should be no connect timeout.
622 *
623 * @param connectTimeout The maximum length of time in milliseconds that a
624 * connection attempt should be allowed to continue
625 * before giving up.
626 */
627 public void setConnectTimeoutMillis(final int connectTimeout)
628 {
629 this.connectTimeout = connectTimeout;
630 }
631
632
633
634 /**
635 * Retrieves the maximum length of time in milliseconds that an operation
636 * should be allowed to block while waiting for a response from the server.
637 * This may be overridden on a per-operation basis.
638 *
639 * @return The maximum length of time in milliseconds that an operation
640 * should be allowed to block while waiting for a response from the
641 * server, or zero if there should not be any default timeout.
642 */
643 public long getResponseTimeoutMillis()
644 {
645 return responseTimeout;
646 }
647
648
649
650 /**
651 * Specifies the maximum length of time in milliseconds that an operation
652 * should be allowed to block while waiting for a response from the server. A
653 * value of zero indicates that there should be no timeout.
654 *
655 * @param responseTimeout The maximum length of time in milliseconds that an
656 * operation should be allowed to block while waiting
657 * for a response from the server.
658 *
659 */
660 public void setResponseTimeoutMillis(final long responseTimeout)
661 {
662 if (responseTimeout < 0)
663 {
664 this.responseTimeout = 0L;
665 }
666 else
667 {
668 this.responseTimeout = responseTimeout;
669 }
670 }
671
672
673
674 /**
675 * Indicates whether the LDAP SDK should attempt to abandon any request for
676 * which no response is received in the maximum response timeout period.
677 *
678 * @return {@code true} if the LDAP SDK should attempt to abandon any request
679 * for which no response is received in the maximum response timeout
680 * period, or {@code false} if no abandon attempt should be made in
681 * this circumstance.
682 */
683 public boolean abandonOnTimeout()
684 {
685 return abandonOnTimeout;
686 }
687
688
689
690 /**
691 * Specifies whether the LDAP SDK should attempt to abandon any request for
692 * which no response is received in the maximum response timeout period.
693 *
694 * @param abandonOnTimeout Indicates whether the LDAP SDK should attempt to
695 * abandon any request for which no response is
696 * received in the maximum response timeout period.
697 */
698 public void setAbandonOnTimeout(final boolean abandonOnTimeout)
699 {
700 this.abandonOnTimeout = abandonOnTimeout;
701 }
702
703
704
705 /**
706 * Indicates whether to use the SO_KEEPALIVE option for the underlying sockets
707 * used by associated connections.
708 *
709 * @return {@code true} if the SO_KEEPALIVE option should be used for the
710 * underlying sockets, or {@code false} if not.
711 */
712 public boolean useKeepAlive()
713 {
714 return useKeepAlive;
715 }
716
717
718
719 /**
720 * Specifies whether to use the SO_KEEPALIVE option for the underlying sockets
721 * used by associated connections. Changes to this setting will take effect
722 * only for new sockets, and not for existing sockets.
723 *
724 * @param useKeepAlive Indicates whether to use the SO_KEEPALIVE option for
725 * the underlying sockets used by associated
726 * connections.
727 */
728 public void setUseKeepAlive(final boolean useKeepAlive)
729 {
730 this.useKeepAlive = useKeepAlive;
731 }
732
733
734
735 /**
736 * Indicates whether to use the SO_LINGER option for the underlying sockets
737 * used by associated connections.
738 *
739 * @return {@code true} if the SO_LINGER option should be used for the
740 * underlying sockets, or {@code false} if not.
741 */
742 public boolean useLinger()
743 {
744 return useLinger;
745 }
746
747
748
749 /**
750 * Retrieves the linger timeout in seconds that will be used if the SO_LINGER
751 * socket option is enabled.
752 *
753 * @return The linger timeout in seconds that will be used if the SO_LINGER
754 * socket option is enabled.
755 */
756 public int getLingerTimeoutSeconds()
757 {
758 return lingerTimeout;
759 }
760
761
762
763 /**
764 * Specifies whether to use the SO_LINGER option for the underlying sockets
765 * used by associated connections. Changes to this setting will take effect
766 * only for new sockets, and not for existing sockets.
767 *
768 * @param useLinger Indicates whether to use the SO_LINGER option for
769 * the underlying sockets used by associated
770 * connections.
771 * @param lingerTimeout The linger timeout in seconds that should be used if
772 * this capability is enabled.
773 */
774 public void setUseLinger(final boolean useLinger, final int lingerTimeout)
775 {
776 this.useLinger = useLinger;
777 this.lingerTimeout = lingerTimeout;
778 }
779
780
781
782 /**
783 * Indicates whether to use the SO_REUSEADDR option for the underlying sockets
784 * used by associated connections.
785 *
786 * @return {@code true} if the SO_REUSEADDR option should be used for the
787 * underlying sockets, or {@code false} if not.
788 */
789 public boolean useReuseAddress()
790 {
791 return useReuseAddress;
792 }
793
794
795
796 /**
797 * Specifies whether to use the SO_REUSEADDR option for the underlying sockets
798 * used by associated connections. Changes to this setting will take effect
799 * only for new sockets, and not for existing sockets.
800 *
801 * @param useReuseAddress Indicates whether to use the SO_REUSEADDR option
802 * for the underlying sockets used by associated
803 * connections.
804 */
805 public void setUseReuseAddress(final boolean useReuseAddress)
806 {
807 this.useReuseAddress = useReuseAddress;
808 }
809
810
811
812 /**
813 * Indicates whether to try to use schema information when reading data from
814 * the server (e.g., to select the appropriate matching rules for the
815 * attributes included in a search result entry).
816 *
817 * @return {@code true} if schema should be used when reading data from the
818 * server, or {@code false} if not.
819 */
820 public boolean useSchema()
821 {
822 return useSchema;
823 }
824
825
826
827 /**
828 * Specifies whether to try to use schema information when reading data from
829 * the server (e.g., to select the appropriate matching rules for the
830 * attributes included in a search result entry).
831 * <BR><BR>
832 * Note that calling this method with a value of {@code true} will also cause
833 * the {@code usePooledSchema} setting to be given a value of false, since
834 * the two values should not both be {@code true} at the same time.
835 *
836 * @param useSchema Indicates whether to try to use schema information when
837 * reading data from the server.
838 */
839 public void setUseSchema(final boolean useSchema)
840 {
841 this.useSchema = useSchema;
842 if (useSchema)
843 {
844 usePooledSchema = false;
845 }
846 }
847
848
849
850 /**
851 * Indicates whether to have connections that are part of a pool try to use
852 * shared schema information when reading data from the server (e.g., to
853 * select the appropriate matching rules for the attributes included in a
854 * search result entry). If this is {@code true}, then connections in a
855 * connection pool will share the same cached schema information in a way that
856 * attempts to reduce network bandwidth and connection establishment time (by
857 * avoiding the need for each connection to retrieve its own copy of the
858 * schema).
859 * <BR><BR>
860 * If pooled schema is to be used, then it may be configured to expire so that
861 * the schema may be periodically re-retrieved for new connections to allow
862 * schema updates to be incorporated. This behavior is controlled by the
863 * value returned by the {@link #getPooledSchemaTimeoutMillis} method.
864 *
865 * @return {@code true} if all connections in a connection pool should
866 * reference the same schema object, or {@code false} if each
867 * connection should retrieve its own copy of the schema.
868 */
869 public boolean usePooledSchema()
870 {
871 return usePooledSchema;
872 }
873
874
875
876 /**
877 * Indicates whether to have connections that are part of a pool try to use
878 * shared schema information when reading data from the server (e.g., to
879 * select the appropriate matching rules for the attributes included in a
880 * search result entry).
881 * <BR><BR>
882 * Note that calling this method with a value of {@code true} will also cause
883 * the {@code useSchema} setting to be given a value of false, since the two
884 * values should not both be {@code true} at the same time.
885 *
886 * @param usePooledSchema Indicates whether all connections in a connection
887 * pool should reference the same schema object
888 * rather than attempting to retrieve their own copy
889 * of the schema.
890 */
891 public void setUsePooledSchema(final boolean usePooledSchema)
892 {
893 this.usePooledSchema = usePooledSchema;
894 if (usePooledSchema)
895 {
896 useSchema = false;
897 }
898 }
899
900
901
902 /**
903 * Retrieves the maximum length of time in milliseconds that a pooled schema
904 * object should be considered fresh. If the schema referenced by a
905 * connection pool is at least this old, then the next connection attempt may
906 * cause a new version of the schema to be retrieved.
907 * <BR><BR>
908 * This will only be used if the {@link #usePooledSchema} method returns
909 * {@code true}. A value of zero indicates that the pooled schema will never
910 * expire.
911 *
912 * @return The maximum length of time, in milliseconds, that a pooled schema
913 * object should be considered fresh, or zero if pooled schema
914 * objects should never expire.
915 */
916 public long getPooledSchemaTimeoutMillis()
917 {
918 return pooledSchemaTimeout;
919 }
920
921
922
923 /**
924 * Specifies the maximum length of time in milliseconds that a pooled schema
925 * object should be considered fresh.
926 *
927 * @param pooledSchemaTimeout The maximum length of time in milliseconds
928 * that a pooled schema object should be
929 * considered fresh. A value less than or equal
930 * to zero will indicate that pooled schema
931 * should never expire.
932 */
933 public void setPooledSchemaTimeoutMillis(final long pooledSchemaTimeout)
934 {
935 if (pooledSchemaTimeout < 0)
936 {
937 this.pooledSchemaTimeout = 0L;
938 }
939 else
940 {
941 this.pooledSchemaTimeout = pooledSchemaTimeout;
942 }
943 }
944
945
946
947 /**
948 * Indicates whether to operate in synchronous mode, in which at most one
949 * operation may be in progress at any time on a given connection, which may
950 * allow it to operate more efficiently and without requiring a separate
951 * reader thread per connection. The LDAP SDK will not absolutely enforce
952 * this restriction, but when operating in this mode correct behavior
953 * cannot be guaranteed when multiple attempts are made to use a connection
954 * for multiple concurrent operations.
955 * <BR><BR>
956 * Note that if synchronous mode is to be used, then this connection option
957 * must be set on the connection before any attempt is made to establish the
958 * connection. Once the connection has been established, then it will
959 * continue to operate in synchronous or asynchronous mode based on the
960 * options in place at the time it was connected.
961 *
962 * @return {@code true} if associated connections should operate in
963 * synchronous mode, or {@code false} if not.
964 */
965 public boolean useSynchronousMode()
966 {
967 return useSynchronousMode;
968 }
969
970
971
972 /**
973 * Specifies whether to operate in synchronous mode, in which at most one
974 * operation may be in progress at any time on a given connection.
975 * <BR><BR>
976 * Note that if synchronous mode is to be used, then this connection option
977 * must be set on the connection before any attempt is made to establish the
978 * connection. Once the connection has been established, then it will
979 * continue to operate in synchronous or asynchronous mode based on the
980 * options in place at the time it was connected.
981 *
982 * @param useSynchronousMode Indicates whether to operate in synchronous
983 * mode.
984 */
985 public void setUseSynchronousMode(final boolean useSynchronousMode)
986 {
987 this.useSynchronousMode = useSynchronousMode;
988 }
989
990
991
992 /**
993 * Indicates whether to use the TCP_NODELAY option for the underlying sockets
994 * used by associated connections.
995 *
996 * @return {@code true} if the TCP_NODELAY option should be used for the
997 * underlying sockets, or {@code false} if not.
998 */
999 public boolean useTCPNoDelay()
1000 {
1001 return useTCPNoDelay;
1002 }
1003
1004
1005
1006 /**
1007 * Specifies whether to use the TCP_NODELAY option for the underlying sockets
1008 * used by associated connections. Changes to this setting will take effect
1009 * only for new sockets, and not for existing sockets.
1010 *
1011 * @param useTCPNoDelay Indicates whether to use the TCP_NODELAY option for
1012 * the underlying sockets used by associated
1013 * connections.
1014 */
1015 public void setUseTCPNoDelay(final boolean useTCPNoDelay)
1016 {
1017 this.useTCPNoDelay = useTCPNoDelay;
1018 }
1019
1020
1021
1022 /**
1023 * Indicates whether associated connections should attempt to follow any
1024 * referrals that they encounter.
1025 *
1026 * @return {@code true} if associated connections should attempt to follow
1027 * any referrals that they encounter, or {@code false} if not.
1028 */
1029 public boolean followReferrals()
1030 {
1031 return followReferrals;
1032 }
1033
1034
1035
1036 /**
1037 * Specifies whether associated connections should attempt to follow any
1038 * referrals that they encounter, using the referral connector for the
1039 * associated connection.
1040 *
1041 * @param followReferrals Specifies whether associated connections should
1042 * attempt to follow any referrals that they
1043 * encounter.
1044 */
1045 public void setFollowReferrals(final boolean followReferrals)
1046 {
1047 this.followReferrals = followReferrals;
1048 }
1049
1050
1051
1052 /**
1053 * Retrieves the maximum number of hops that a connection should take when
1054 * trying to follow a referral.
1055 *
1056 * @return The maximum number of hops that a connection should take when
1057 * trying to follow a referral.
1058 */
1059 public int getReferralHopLimit()
1060 {
1061 return referralHopLimit;
1062 }
1063
1064
1065
1066 /**
1067 * Specifies the maximum number of hops that a connection should take when
1068 * trying to follow a referral.
1069 *
1070 * @param referralHopLimit The maximum number of hops that a connection
1071 * should take when trying to follow a referral. It
1072 * must be greater than zero.
1073 */
1074 public void setReferralHopLimit(final int referralHopLimit)
1075 {
1076 ensureTrue(referralHopLimit > 0,
1077 "LDAPConnectionOptions.referralHopLimit must be greater than 0.");
1078
1079 this.referralHopLimit = referralHopLimit;
1080 }
1081
1082
1083
1084 /**
1085 * Retrieves the referral connector that will be used to establish and
1086 * optionally authenticate connections to servers when attempting to follow
1087 * referrals, if defined.
1088 *
1089 * @return The referral connector that will be used to establish and
1090 * optionally authenticate connections to servers when attempting to
1091 * follow referrals, or {@code null} if no specific referral
1092 * connector has been configured and referral connections should be
1093 * created using the same socket factory and bind request as the
1094 * connection on which the referral was received.
1095 */
1096 public ReferralConnector getReferralConnector()
1097 {
1098 return referralConnector;
1099 }
1100
1101
1102
1103 /**
1104 * Specifies the referral connector that should be used to establish and
1105 * optionally authenticate connections to servers when attempting to follow
1106 * referrals.
1107 *
1108 * @param referralConnector The referral connector that will be used to
1109 * establish and optionally authenticate
1110 * connections to servers when attempting to follow
1111 * referrals. It may be {@code null} to indicate
1112 * that the same socket factory and bind request
1113 * as the connection on which the referral was
1114 * received should be used to establish and
1115 * authenticate connections for following
1116 * referrals.
1117 */
1118 public void setReferralConnector(final ReferralConnector referralConnector)
1119 {
1120 this.referralConnector = referralConnector;
1121 }
1122
1123
1124
1125 /**
1126 * Retrieves the maximum size in bytes for an LDAP message that a connection
1127 * will attempt to read from the directory server. If it encounters an LDAP
1128 * message that is larger than this size, then the connection will be
1129 * terminated.
1130 *
1131 * @return The maximum size in bytes for an LDAP message that a connection
1132 * will attempt to read from the directory server, or 0 if no limit
1133 * will be enforced.
1134 */
1135 public int getMaxMessageSize()
1136 {
1137 return maxMessageSize;
1138 }
1139
1140
1141
1142 /**
1143 * Specifies the maximum size in bytes for an LDAP message that a connection
1144 * will attempt to read from the directory server. If it encounters an LDAP
1145 * message that is larger than this size, then the connection will be
1146 * terminated.
1147 *
1148 * @param maxMessageSize The maximum size in bytes for an LDAP message that
1149 * a connection will attempt to read from the
1150 * directory server. A value less than or equal to
1151 * zero indicates that no limit should be enforced.
1152 */
1153 public void setMaxMessageSize(final int maxMessageSize)
1154 {
1155 if (maxMessageSize > 0)
1156 {
1157 this.maxMessageSize = maxMessageSize;
1158 }
1159 else
1160 {
1161 this.maxMessageSize = 0;
1162 }
1163 }
1164
1165
1166
1167 /**
1168 * Retrieves the disconnect handler to use for associated connections.
1169 *
1170 * @return the disconnect handler to use for associated connections, or
1171 * {@code null} if none is defined.
1172 */
1173 public DisconnectHandler getDisconnectHandler()
1174 {
1175 return disconnectHandler;
1176 }
1177
1178
1179
1180 /**
1181 * Specifies the disconnect handler to use for associated connections.
1182 *
1183 * @param handler The disconnect handler to use for associated connections.
1184 */
1185 public void setDisconnectHandler(final DisconnectHandler handler)
1186 {
1187 disconnectHandler = handler;
1188 }
1189
1190
1191
1192 /**
1193 * Retrieves the unsolicited notification handler to use for associated
1194 * connections.
1195 *
1196 * @return The unsolicited notification handler to use for associated
1197 * connections, or {@code null} if none is defined.
1198 */
1199 public UnsolicitedNotificationHandler getUnsolicitedNotificationHandler()
1200 {
1201 return unsolicitedNotificationHandler;
1202 }
1203
1204
1205
1206 /**
1207 * Specifies the unsolicited notification handler to use for associated
1208 * connections.
1209 *
1210 * @param handler The unsolicited notification handler to use for associated
1211 * connections.
1212 */
1213 public void setUnsolicitedNotificationHandler(
1214 final UnsolicitedNotificationHandler handler)
1215 {
1216 unsolicitedNotificationHandler = handler;
1217 }
1218
1219
1220
1221 /**
1222 * Retrieves the socket receive buffer size that should be requested when
1223 * establishing a connection.
1224 *
1225 * @return The socket receive buffer size that should be requested when
1226 * establishing a connection, or zero if the default size should be
1227 * used.
1228 */
1229 public int getReceiveBufferSize()
1230 {
1231 return receiveBufferSize;
1232 }
1233
1234
1235
1236 /**
1237 * Specifies the socket receive buffer size that should be requested when
1238 * establishing a connection.
1239 *
1240 * @param receiveBufferSize The socket receive buffer size that should be
1241 * requested when establishing a connection, or
1242 * zero if the default size should be used.
1243 */
1244 public void setReceiveBufferSize(final int receiveBufferSize)
1245 {
1246 if (receiveBufferSize < 0)
1247 {
1248 this.receiveBufferSize = 0;
1249 }
1250 else
1251 {
1252 this.receiveBufferSize = receiveBufferSize;
1253 }
1254 }
1255
1256
1257
1258 /**
1259 * Retrieves the socket send buffer size that should be requested when
1260 * establishing a connection.
1261 *
1262 * @return The socket send buffer size that should be requested when
1263 * establishing a connection, or zero if the default size should be
1264 * used.
1265 */
1266 public int getSendBufferSize()
1267 {
1268 return sendBufferSize;
1269 }
1270
1271
1272
1273 /**
1274 * Specifies the socket send buffer size that should be requested when
1275 * establishing a connection.
1276 *
1277 * @param sendBufferSize The socket send buffer size that should be
1278 * requested when establishing a connection, or zero
1279 * if the default size should be used.
1280 */
1281 public void setSendBufferSize(final int sendBufferSize)
1282 {
1283 if (sendBufferSize < 0)
1284 {
1285 this.sendBufferSize = 0;
1286 }
1287 else
1288 {
1289 this.sendBufferSize = sendBufferSize;
1290 }
1291 }
1292
1293
1294
1295 /**
1296 * Indicates whether to allow a socket factory instance (which may be shared
1297 * across multiple connections) to be used create multiple sockets
1298 * concurrently. In general, socket factory implementations are threadsafe
1299 * and can be to create multiple connections simultaneously across separate
1300 * threads, but this is known to not be the case in some VM implementations
1301 * (e.g., SSL socket factories in IBM JVMs). This setting may be used to
1302 * indicate whether concurrent socket creation attempts should be allowed
1303 * (which may allow for better and more consistent performance, especially in
1304 * cases where a connection attempt fails due to a timeout) or prevented
1305 * (which may be necessary for non-threadsafe socket factory implementations).
1306 *
1307 * @return {@code true} if multiple threads should be able to concurrently
1308 * use the same socket factory instance, or {@code false} if Java
1309 * synchronization should be used to ensure that no more than one
1310 * thread is allowed to use a socket factory at any given time.
1311 */
1312 public boolean allowConcurrentSocketFactoryUse()
1313 {
1314 return allowConcurrentSocketFactoryUse;
1315 }
1316
1317
1318
1319 /**
1320 * Specifies whether to allow a socket factory instance (which may be shared
1321 * across multiple connections) to be used create multiple sockets
1322 * concurrently. In general, socket factory implementations are threadsafe
1323 * and can be to create multiple connections simultaneously across separate
1324 * threads, but this is known to not be the case in some VM implementations
1325 * (e.g., SSL socket factories in IBM JVMs). This setting may be used to
1326 * indicate whether concurrent socket creation attempts should be allowed
1327 * (which may allow for better and more consistent performance, especially in
1328 * cases where a connection attempt fails due to a timeout) or prevented
1329 * (which may be necessary for non-threadsafe socket factory implementations).
1330 *
1331 * @param allowConcurrentSocketFactoryUse Indicates whether to allow a
1332 * socket factory instance to be used
1333 * to create multiple sockets
1334 * concurrently.
1335 */
1336 public void setAllowConcurrentSocketFactoryUse(
1337 final boolean allowConcurrentSocketFactoryUse)
1338 {
1339 this.allowConcurrentSocketFactoryUse = allowConcurrentSocketFactoryUse;
1340 }
1341
1342
1343
1344 /**
1345 * Retrieves the {@link SSLSocketVerifier} that will be used to perform
1346 * additional validation for any newly-created {@code SSLSocket} instances.
1347 *
1348 * @return The {@code SSLSocketVerifier} that will be used to perform
1349 * additional validation for any newly-created {@code SSLSocket}
1350 * instances.
1351 */
1352 public SSLSocketVerifier getSSLSocketVerifier()
1353 {
1354 return sslSocketVerifier;
1355 }
1356
1357
1358
1359 /**
1360 * Specifies the {@link SSLSocketVerifier} that will be used to perform
1361 * additional validation for any newly-created {@code SSLSocket} instances.
1362 *
1363 * @param sslSocketVerifier The {@code SSLSocketVerifier} that will be used
1364 * to perform additional validation for any
1365 * newly-created {@code SSLSocket} instances.
1366 */
1367 public void setSSLSocketVerifier(final SSLSocketVerifier sslSocketVerifier)
1368 {
1369 if (sslSocketVerifier == null)
1370 {
1371 this.sslSocketVerifier = DEFAULT_SSL_SOCKET_VERIFIER;
1372 }
1373 else
1374 {
1375 this.sslSocketVerifier = sslSocketVerifier;
1376 }
1377 }
1378
1379
1380
1381 /**
1382 * Retrieves a string representation of this LDAP connection.
1383 *
1384 * @return A string representation of this LDAP connection.
1385 */
1386 @Override()
1387 public String toString()
1388 {
1389 final StringBuilder buffer = new StringBuilder();
1390 toString(buffer);
1391 return buffer.toString();
1392 }
1393
1394
1395
1396 /**
1397 * Appends a string representation of this LDAP connection to the provided
1398 * buffer.
1399 *
1400 * @param buffer The buffer to which to append a string representation of
1401 * this LDAP connection.
1402 */
1403 public void toString(final StringBuilder buffer)
1404 {
1405 buffer.append("LDAPConnectionOptions(autoReconnect=");
1406 buffer.append(autoReconnect);
1407 buffer.append(", bindWithDNRequiresPassword=");
1408 buffer.append(bindWithDNRequiresPassword);
1409 buffer.append(", followReferrals=");
1410 buffer.append(followReferrals);
1411 if (followReferrals)
1412 {
1413 buffer.append(", referralHopLimit=");
1414 buffer.append(referralHopLimit);
1415 }
1416 if (referralConnector != null)
1417 {
1418 buffer.append(", referralConnectorClass=");
1419 buffer.append(referralConnector.getClass().getName());
1420 }
1421 buffer.append(", useKeepAlive=");
1422 buffer.append(useKeepAlive);
1423 buffer.append(", useLinger=");
1424 if (useLinger)
1425 {
1426 buffer.append("true, lingerTimeoutSeconds=");
1427 buffer.append(lingerTimeout);
1428 }
1429 else
1430 {
1431 buffer.append("false");
1432 }
1433 buffer.append(", useReuseAddress=");
1434 buffer.append(useReuseAddress);
1435 buffer.append(", useSchema=");
1436 buffer.append(useSchema);
1437 buffer.append(", usePooledSchema=");
1438 buffer.append(usePooledSchema);
1439 buffer.append(", pooledSchemaTimeoutMillis=");
1440 buffer.append(pooledSchemaTimeout);
1441 buffer.append(", useSynchronousMode=");
1442 buffer.append(useSynchronousMode);
1443 buffer.append(", useTCPNoDelay=");
1444 buffer.append(useTCPNoDelay);
1445 buffer.append(", captureConnectStackTrace=");
1446 buffer.append(captureConnectStackTrace);
1447 buffer.append(", connectTimeoutMillis=");
1448 buffer.append(connectTimeout);
1449 buffer.append(", responseTimeoutMillis=");
1450 buffer.append(responseTimeout);
1451 buffer.append(", abandonOnTimeout=");
1452 buffer.append(abandonOnTimeout);
1453 buffer.append(", maxMessageSize=");
1454 buffer.append(maxMessageSize);
1455 buffer.append(", receiveBufferSize=");
1456 buffer.append(receiveBufferSize);
1457 buffer.append(", sendBufferSize=");
1458 buffer.append(sendBufferSize);
1459 buffer.append(", allowConcurrentSocketFactoryUse=");
1460 buffer.append(allowConcurrentSocketFactoryUse);
1461 if (disconnectHandler != null)
1462 {
1463 buffer.append(", disconnectHandlerClass=");
1464 buffer.append(disconnectHandler.getClass().getName());
1465 }
1466 if (unsolicitedNotificationHandler != null)
1467 {
1468 buffer.append(", unsolicitedNotificationHandlerClass=");
1469 buffer.append(unsolicitedNotificationHandler.getClass().getName());
1470 }
1471
1472 buffer.append(", sslSocketVerifierClass='");
1473 buffer.append(sslSocketVerifier.getClass().getName());
1474 buffer.append('\'');
1475
1476 buffer.append(')');
1477 }
1478 }