host:
                          type: string
                          format: hostname
                          example: "fess.codelibs.org"
                        last_modified:
                          type: string
                          format: date-time

            trans = SmbTransport.getSmbTransport(addr, url.getPort());
            tree = trans.getSmbSession(auth).getSmbTree(share, null);
        }

        String hostName = getServerWithDfs();
        tree.inDomainDfs = dfs.resolve(hostName, tree.share, null, auth) != null;
        if (tree.inDomainDfs) {
            tree.connectionState = 2;
        }

        try {
            if( log.level >= 3 )

		EnvVar: "MINIO_CONFIG",
	},
	cli.StringFlag{
		Name:   "address",
		Value:  ":" + GlobalMinioDefaultPort,
		Usage:  "bind to a specific ADDRESS:PORT, ADDRESS can be an IP or hostname",
		EnvVar: "MINIO_ADDRESS",
	},
	cli.IntFlag{
		Name:   "listeners", // Deprecated Oct 2022
		Value:  1,
		Usage:  "bind N number of listeners per ADDRESS:PORT",
		EnvVar: "MINIO_LISTENERS",
		Hidden: true,

     * 
     * @return local address to use for outgoing connections
     */
    InetAddress getLocalAddr ();


    /**
     * 
     * Property <tt>jcifs.netbios.hostname</tt> (string)
     * 
     * @return local NETBIOS/short name to announce
     */
    String getNetbiosHostname ();


    /**
     * 
     * Property <tt>jcifs.smb.client.logonShare</tt>
     * 

                        "stat_prefix": "connect_originate",
                        "cluster": "connect_originate",
                        "tunneling_config": {
                          "hostname": "%DOWNSTREAM_LOCAL_ADDRESS%"
                        }
                      }
                    }
                  ]
                }
              ],
              "use_original_dst": false,

	if !found {
		// In distributed setup, anonymized addr = 'poolNum.serverNum'
		newHost := fmt.Sprintf("pool%d.server%d", poolNum, srvrNum)
		schemePfx := endpoint.Scheme + "://"

		// Hostname
		mapIfNotPresent(hostAnonymizer, endpoint.Hostname(), newHost)

		newHostPort := newHost
		if len(endpoint.Port()) > 0 {
			// Host + port
			newHostPort = newHost + ":" + endpoint.Port()

# common
crawler.default.script=groovy
crawler.http.thread_pool.size=0
crawler.document.max.site.length=100
crawler.document.site.encoding=UTF-8
crawler.document.unknown.hostname=unknown
crawler.document.use.site.encoding.on.english=false
crawler.document.append.data=true
crawler.document.append.filename=false
crawler.document.max.alphanum.term.size=20
crawler.document.max.symbol.term.size=10

func (client *storageRESTClient) LastConn() time.Time {
	return client.restClient.LastConn()
}

func (client *storageRESTClient) IsLocal() bool {
	return false
}

func (client *storageRESTClient) Hostname() string {
	return client.endpoint.Host
}

func (client *storageRESTClient) Endpoint() Endpoint {
	return client.endpoint
}

func (client *storageRESTClient) Healing() *healingTracker {

# These old versions are surprisingly common, so build in a check here
define warning
Docker version is too old, please upgrade to a newer version.
endef
ifneq ($(findstring google,$(HOSTNAME)),)
warning+=Googlers: go/installdocker\#the-version-of-docker-thats-installed-is-old-eg-1126
endif
# The old docker issue manifests as not being able to run *any* binary. So we can test

pkg net, type Resolver struct
pkg net, type Resolver struct, PreferGo bool
pkg net/url, func PathEscape(string) string
pkg net/url, func PathUnescape(string) (string, error)
pkg net/url, method (*URL) Hostname() string
pkg net/url, method (*URL) MarshalBinary() ([]uint8, error)
pkg net/url, method (*URL) Port() string
pkg net/url, method (*URL) UnmarshalBinary([]uint8) error
pkg net, var DefaultResolver *Resolver