}

  /**
   * Invoked immediately after a TLS connection was attempted.
   *
   * This method is invoked after [secureConnectStart].
   */
  open fun secureConnectEnd(
    call: Call,
    handshake: Handshake?,
  ) {
  }

  /**
   * Invoked immediately after a socket connection was attempted.
   *

        return errorCode.isRetryable() && retryPolicy != RetryPolicy.NO_RETRY;
    }

    /**
     * Check if retry should be attempted
     *
     * @param attemptNumber the current attempt number
     * @return true if retry should be attempted
     */
    public boolean shouldRetry(int attemptNumber) {
        return retryPolicy.shouldRetry(this, attemptNumber);
    }

    /**

          return null
        }
        val priorResponse = userResponse.priorResponse
        if (priorResponse != null && priorResponse.code == HTTP_CLIENT_TIMEOUT) {
          // We attempted to retry and got another timeout. Give up.
          return null
        }

        if (retryAfter(userResponse, 0) > 0) {
          return null
        }

        return userResponse.request
      }

            route: Route?,
            response: Response,
          ): Request? {
            if (response.request.header("Authorization") != null) {
              return null // Give up, we've already attempted to authenticate.
            }

            println("Authenticating for response: $response")
            println("Challenges: ${response.challenges()}")
            val credential = Credentials.basic("jesse", "password1")

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.smb;

/**
 * Exception thrown when an unsupported SMB operation is attempted.
 * Indicates that the requested operation is not supported by the SMB server or protocol version.
 *
 * @author mbechler
 *
 */
public class SmbUnsupportedOperationException extends SmbException {

    /**

import java.util.concurrent.atomic.AtomicBoolean
import okio.ByteString
import okio.Source
import okio.buffer

internal abstract class BasePublicSuffixList : PublicSuffixList {
  /** True after we've attempted to read the list for the first time. */
  private val listRead = AtomicBoolean(false)

  /** Used for concurrent threads reading the list for the first time. */
  private val readCompleteLatch = CountDownLatch(1)

        assertTrue(ex.getMessage().contains("Server does not support kerberos authentication"));
        // No fallback attempted; config should not be queried in this path
        verify(tc, never()).getConfig();
        verifyNoInteractions(config);
    }

    @Test

        }

        /**
         * Get retry count
         *
         * @return number of retry attempts
         */
        public int getRetryCount() {
            return retryCount;
        }

        /**
         * Get next retry time
         *
         * @return time of next retry attempt
         */
        public long getNextRetryTime() {
            return nextRetryTime;
        }

    ```kotlin
    if (credential == response.request.header("Authorization")) {
      return null // If we already failed with these credentials, don't retry.
     }
    ```

    You may also skip the retry when you’ve hit an application-defined attempt limit:

    ```kotlin
    if (response.responseCount >= 3) {

	if !client.IsOnlineWS() {
		// make sure to check if the disk is offline, since the underlying
		// value is cached we should attempt to invalidate it if such calls
		// were attempted. This can lead to false success under certain conditions
		// - this change attempts to avoid stale information if the underlying
		// transport is already down.
		return "", errDiskNotFound
	}