return;
                }
            } else { /* Basic */
                String auth = new String( Base64.decode( msg.substring(6) ), "US-ASCII" );
                int index = auth.indexOf( ':' );
                String user = (index != -1) ? auth.substring(0, index) : auth;
                String password = (index != -1) ? auth.substring(index + 1) : "";
                index = user.indexOf('\\');

labels.file_auth_configuration=Datei-Authentifizierung
labels.file_auth_list_hostname=Hostname
labels.file_auth_list_file_crawling_config=Konfigurationsname
labels.file_auth_any=Beliebig
labels.file_auth_create_file_config=Erstelle neue Datei-Konfiguration
labels.file_auth_title_details=Datei-Authentifizierung
labels.file_auth_hostname=Hostname
labels.file_auth_port=Port
labels.file_auth_scheme=Schema

labels.file_auth_configuration=ファイル認証
labels.file_auth_list_hostname=ホスト名
labels.file_auth_list_file_crawling_config=設定名
labels.file_auth_any=任意
labels.file_auth_create_file_config=新しいファイルクロール設定の作成
labels.file_auth_title_details=ファイル認証
labels.file_auth_hostname=ホスト名
labels.file_auth_port=ポート
labels.file_auth_scheme=スキーム
labels.file_auth_username=ユーザー名
labels.file_auth_password=パスワード

    val responseCode = userResponse.code

    val method = userResponse.request.method
    when (responseCode) {
      HTTP_PROXY_AUTH -> {
        val selectedProxy = route!!.proxy
        if (selectedProxy.type() != Proxy.Type.HTTP) {
          throw ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy")
        }
        return client.proxyAuthenticator.authenticate(route, userResponse)
      }

	}

	listType := r.Form.Get("listType")
	if listType != "sts-only" && listType != "svcacc-only" && listType != "" {
		// default to both
		listType = ""
	}

	var serviceAccounts []auth.Credentials
	var stsKeys []auth.Credentials

	if listType == "" || listType == "sts-only" {
		stsKeys, err = globalIAMSys.ListSTSAccounts(ctx, targetAccount)
		if err != nil {

    val nextTunnelRequest =
      createTunnel()
        ?: return ConnectResult(plan = this) // Success.

    // The proxy decided to close the connection after an auth challenge. Retry with different
    // auth credentials.
    rawSocket?.closeQuietly()

    val nextAttempt = attempt + 1
    return when {
      nextAttempt < MAX_TUNNEL_ATTEMPTS -> {
        user.callConnectEnd(route, null)

package cmd

import (
	"bytes"
	"context"
	"errors"
	"io"
	"mime"
	"net/http"
	"path/filepath"
	"sort"
	"strings"

	"github.com/minio/minio/internal/auth"
	"github.com/minio/minio/internal/crypto"
	xhttp "github.com/minio/minio/internal/http"
	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/pkg/v2/policy"
	"github.com/minio/zipindex"
)

const (

labels.file_auth_configuration	=	Authentification des fichiers
labels.file_auth_list_hostname	=	Hostname
labels.file_auth_list_file_crawling_config	=	Config Name
labels.file_auth_any	=	Any
labels.file_auth_create_file_config	=	Créer un nouveau fichier Config
labels.file_auth_title_details	=	Authentification des fichiers
labels.file_auth_hostname	=	Hostname
labels.file_auth_port	=	Port
labels.file_auth_scheme	=	Schéma

  //
  // Requests for TLS client certificates typically request: "digital signature", "key encipherment", "client auth".
  //
  // Requests for TLS serving certificates typically request: "key encipherment", "digital signature", "server auth".
  //
  // Valid values are:
  //  "signing", "digital signature", "content commitment",
  //  "key encipherment", "key agreement", "data encipherment",

	if dsecs == "" {
		return l.stsExpiryDuration, nil
	}

	d, err := strconv.Atoi(dsecs)
	if err != nil {
		return 0, auth.ErrInvalidDuration
	}

	dur := time.Duration(d) * time.Second

	if dur < minLDAPExpiry || dur > maxLDAPExpiry {
		return 0, auth.ErrInvalidDuration
	}
	return dur, nil
}

// ParsesAsDN determines if the given string could be a valid DN based on
// parsing alone.