/**
     * Create username/password credentials with specified domain
     *
     * @param domain the domain for authentication
     * @param username the username for authentication
     * @param password the password for authentication
     */
    public NtlmPasswordAuthenticator(String domain, String username, String password) {
        this(domain, username, password, (AuthenticationType) null);
    }

    /**

    * Dolayısıyla **sertifika ve şifreleme** işlemleri **HTTP’den önce** yapılır.
* **TCP "domain"leri bilmez**. Yalnızca IP adreslerini bilir.
    * İstenen **spesifik domain** bilgisi **HTTP verisinin** içindedir.
* **HTTPS sertifikaları** belirli bir **domain**’i "sertifikalandırır"; ancak protokol ve şifreleme TCP seviyesinde, hangi domain ile çalışıldığı **henüz bilinmeden** gerçekleşir.

            this.authType = authType;
            this.timestamp = System.currentTimeMillis();
            this.clientAddress = clientAddress;
            this.serverAddress = serverAddress;
        }

        public String getUsername() {
            return username;
        }

        public String getDomain() {
            return domain;
        }

            // Default constructor
        }

        /** Domain NetBIOS name. */
        public rpc.unicode_string name;
        /** DNS domain name. */
        public rpc.unicode_string dns_domain;
        /** DNS forest name. */
        public rpc.unicode_string dns_forest;
        /** Domain GUID. */
        public rpc.uuid_t domain_guid;
        /** Domain security identifier. */
        public rpc.sid_t sid;

     */
    protected NtlmServlet() {
        super();
    }

    /** The default domain for NTLM authentication */
    private String defaultDomain;

    /** The domain controller for authentication */
    private String domainController;

    /** Flag to enable load balancing across domain controllers */
    private boolean loadBalance;

    /** Flag to enable basic authentication */

     */
    void setPath(String path);

    /**
     * Sets the full UNC path components.
     *
     * @param domain the domain name
     * @param server the server name
     * @param fullPath the full UNC path
     */
    void setFullUNCPath(String domain, String server, String fullPath);

    /**
     * Sets whether to resolve this request path in DFS.
     *

    // checkPublicSuffix("a.b.example.local", null);
    // TLD with only 1 rule.
    checkPublicSuffix("biz", null)
    checkPublicSuffix("domain.biz", "domain.biz")
    checkPublicSuffix("b.domain.biz", "domain.biz")
    checkPublicSuffix("a.b.domain.biz", "domain.biz")
    // TLD with some 2-level rules.
    checkPublicSuffix("com", null)
    checkPublicSuffix("example.com", "example.com")

	if result1 != "service.staging.cluster.local.skydns" {
		t.Errorf("Failure to get domain from etcd key (with a trailing '/'), expect: 'service.staging.cluster.local.', actually get: '%s'", result1)
	}

	result2 := msgUnPath("/skydns/local/cluster/staging/service")
	if result2 != "service.staging.cluster.local.skydns" {

    }

    // Happy path: session retrieval with host/domain variations
    @ParameterizedTest
    @DisplayName("getSmbSession(ctx,host,domain) returns session for various inputs")
    @CsvSource({ "server,DOMAIN", "server,", ",DOMAIN", "," })
    void getSmbSession_withTarget(String host, String domain) {
        when(transport.getSmbSession(any(jcifs.CIFSContext.class), any(), any())).thenReturn(session);

* **TCP doesn't know about "domains"**. Only about IP addresses.
    * The information about the **specific domain** requested goes in the **HTTP data**.
* The **HTTPS certificates** "certify" a **certain domain**, but the protocol and encryption happen at the TCP level, **before knowing** which domain is being dealt with.
* **By default**, that would mean that you can only have **one HTTPS certificate per IP address**.