return attempts <= maxGlobalAttemptsPerMinute;
    }

    /**
     * Clean up old entries
     */
    private void cleanup() {
        if (closed.get()) {
            return;
        }

        Instant now = Instant.now();

        // Clean up account attempts
        accountAttempts.entrySet().removeIf(entry -> {
            AccountAttempts account = entry.getValue();

                boolean integrity) {
            this.signingKey = signingKey;
            this.established = established;
            this.nbName = nbName;
            this.supportedMechs = supportedMechs != null ? supportedMechs.clone() : new ASN1ObjectIdentifier[0];
            this.flags = flags;
            this.integrity = integrity;
        }

        @Override
        public byte[] getSigningKey() throws CIFSException {

    }
  }

internal fun commonHeadersOf(vararg inputNamesAndValues: String): Headers {
  require(inputNamesAndValues.size % 2 == 0) { "Expected alternating header names and values" }

  // Make a defensive copy and clean it up.
  val namesAndValues: Array<String> = arrayOf(*inputNamesAndValues)
  for (i in namesAndValues.indices) {
    require(namesAndValues[i] != null) { "Headers cannot be null" }

        this.cipherId = cipherId;
        this.dialect = dialect;
        this.keyManager = keyManager;
        this.sessionKey = sessionKey != null ? sessionKey.clone() : null;
        this.preauthIntegrityHash = preauthHash != null ? preauthHash.clone() : null;

        // Generate unique session ID for key management
        this.sessionId = String.format("smb-enc-%d-%d", System.currentTimeMillis(), secureRandom.nextLong());

OkCurl
======

_A curl for the next-generation web._

OkCurl is an OkHttp-backed curl clone which allows you to test OkHttp's HTTP engine (including
HTTP/2) against web servers.

To run locally, make sure you have GRAALVM_HOME set and run

```bash
./okcurl

func (client *peerRESTClient) ReloadPoolMeta(ctx context.Context) error {
	conn := client.gridConn()
	if conn == nil {
		return nil
	}
	_, err := reloadPoolMetaRPC.Call(ctx, conn, grid.NewMSSWith(map[string]string{}))
	return err
}

func (client *peerRESTClient) DeleteUploadID(ctx context.Context, uploadID string) error {
	conn := client.gridConn()
	if conn == nil {
		return nil
	}

#!/bin/bash

set -e -u

echo "Publishing Javadoc and JDiff..."

cd $HOME
git clone -q -b gh-pages "https://x-access-token:${GITHUB_TOKEN}@github.com/google/guava.git" gh-pages > /dev/null
cd gh-pages

git config --global user.name "$GITHUB_ACTOR"
git config --global user.email "$******@****.***"

./updaterelease.sh snapshot

git push -fq origin gh-pages > /dev/null

    }

    @AfterEach
    public void tearDown() throws IOException {
        if (manager != null) {
            manager.shutdown();
        }

        // Clean up system property
        System.clearProperty("jcifs.smb.client.handleStateDirectory");

        // Clean up temp directory
        if (tempDir != null && Files.exists(tempDir)) {
            Files.walk(tempDir)

			return fmt.Errorf("tar file error: %w%s", err, extra)

		// if the header is nil, just skip it (not sure how this happens)
		case header == nil:
			continue
		}

		name := header.Name
		switch path.Clean(name) {
		case ".", slashSeparator:
			continue
		}

		switch header.Typeflag {
		case tar.TypeDir: // = directory
			if o.ignoreDirs {
				continue
			}

import java.util.Deque
import javax.net.ssl.SSLPeerUnverifiedException

/**
 * A certificate chain cleaner that uses a set of trusted root certificates to build the trusted
 * chain. This class duplicates the clean chain building performed during the TLS handshake. We
 * prefer other mechanisms where they exist, such as with
 * [okhttp3.internal.platform.AndroidPlatform.AndroidCertificateChainCleaner].
 *