return nil, errors.New("no bucket name was provided")
	}

	u, err := url.Parse(conf.Endpoint)
	if err != nil {
		return nil, err
	}

	creds := credentials.NewStaticV4(conf.AccessKey, conf.SecretKey, "")
	opts := &minio.Options{
		Creds:           creds,
		Secure:          u.Scheme == "https",
		Transport:       globalRemoteTargetTransport,
		TrailingHeaders: true,
	}
	client, err := minio.New(u.Host, opts)

		// Create the TLS credentials
		creds, errCreds := credentials.NewServerTLSFromFile(s.TLSCert, s.TLSKey)
		if errCreds != nil {
			epLog.Errorf("could not load TLS keys: %s", errCreds)
		}
		opts = append(opts, grpc.Creds(creds))
	} else if s.Port.XDSServer {
		epLog.Infof("Listening GRPC (over xDS-configured mTLS) on %v", p)
		creds, err := xdscreds.NewServerCredentials(xdscreds.ServerOptions{

        try ( SmbFile f = new SmbFile(url) ) {
            Credentials creds = f.getContext().getCredentials();

            assertFalse(creds.isAnonymous());
            assertFalse(creds.isGuest());
            assertTrue(creds instanceof NtlmPasswordAuthenticator);
            NtlmPasswordAuthenticator ntcreds = (NtlmPasswordAuthenticator) creds;

            assertNotNull(ntcreds.getUsername());

}

func newXDSConnection(cfg *Config) (*grpc.ClientConn, error) {
	var opts []grpc.DialOption

	// transport security
	creds, err := xds.NewClientCredentials(xds.ClientOptions{FallbackCreds: insecure.NewCredentials()})
	if err != nil {
		return nil, err
	}
	security := grpc.WithTransportCredentials(creds)
	if len(cfg.XDSTestBootstrap) > 0 {
		r, err := xdsresolver.NewXDSResolverWithConfigForTesting(cfg.XDSTestBootstrap)
		if err != nil {

        Credentials creds;
        try {
            creds = repository.getConfiguredCredentials().getOrNull();
        } catch (Exception e) {
            // In case of exception, we assume compatibility as this will fail later as well
            creds = null;
        }
        if (creds != null && !isUsingCredentialsProvider((ProjectInternal) project, repository.getName(), creds)) {

     * @return a child context using guest credentials
     */
    CIFSContext withGuestCrendentials ();


    /**
     * 
     * @param creds
     * @return a child context using using the given credentials
     */
    CIFSContext withCredentials ( Credentials creds );


    /**
     * @param locationHint
     * @param error
     * @return whether new credentials are obtained
     */

	creds := strings.SplitN(strings.TrimSpace(credElement), "=", 2)
	if len(creds) != 2 {
		return ch, ErrMissingFields
	}
	if creds[0] != "Credential" {
		return ch, ErrMissingCredTag
	}
	credElements := strings.Split(strings.TrimSpace(creds[1]), SlashSeparator)
	if len(credElements) < 5 {
		return ch, ErrCredMalformed
	}

    public boolean hasDefaultCredentials () {
        return this.delegate.hasDefaultCredentials();
    }


    @Override
    public CIFSContext withCredentials ( Credentials creds ) {
        return wrap(this.delegate.withCredentials(creds));
    }


    @Override
    public CIFSContext withDefaultCredentials () {
        return wrap(this.delegate.withDefaultCredentials());
    }


    @Override

	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrAdminConfigBadJSON, err), r.URL)
		return
	}

	var creds madmin.TierCreds
	json := jsoniter.ConfigCompatibleWithStandardLibrary
	if err := json.Unmarshal(reqBytes, &creds); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	}

	stsEndpointURL, err := url.Parse(stsEndpoint)
	if err != nil {
		log.Fatalf("Error parsing sts endpoint: %v", err)
	}

	opts := &minio.Options{
		Creds:  li,
		Secure: stsEndpointURL.Scheme == "https",
	}

	v, err := li.Get()
	if err != nil {
		log.Fatalf("Error retrieving STS credentials: %v", err)
	}

	if displayCreds {