/*
Package gemini implements the Gemini protocol.

Get makes a Gemini request:

	resp, err := gemini.Get("gemini://example.com")
	if err != nil {
		// handle error
	}
	// ...

The client must close the response body when finished with it:

	resp, err := gemini.Get("gemini://example.com")
	if err != nil {
		// handle error
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	// ...

For control over client behavior, create a Client:

	var client gemini.Client
	resp, err := client.Get("gemini://example.com")
	if err != nil {
		// handle error
	}
	// ...

Clients can load their own list of known hosts:

	err := client.KnownHosts.Load("path/to/my/known_hosts")
	if err != nil {
		// handle error
	}

Clients can control when to trust certificates with TrustCertificate:

	client.TrustCertificate = func(hostname string, cert *x509.Certificate, knownHosts *gemini.KnownHosts) error {
		return knownHosts.Lookup(hostname, cert)
	}

Clients can control what to do when a server requests a certificate:

	client.GetCertificate = func(hostname string, store *gemini.CertificateStore) *tls.Certificate {
		// If the certificate is in the store, return it
		if cert, err := store.Lookup(hostname); err == nil {
			return &cert
		}
		// Otherwise, generate a certificate
		duration := time.Hour
		cert, err := gemini.NewCertificate(hostname, duration)
		if err != nil {
			return nil
		}
		// Store and return the certificate
		store.Add(hostname, cert)
		return &cert
	}

Server is a Gemini server.

	var server gemini.Server

Servers must be configured with certificates:

	err := server.CertificateStore.Load("/var/lib/gemini/certs")
	if err != nil {
		// handle error
	}

Servers can accept requests for multiple hosts and schemes:

	server.RegisterFunc("example.com", func(w *gemini.ResponseWriter, r *gemini.Request) {
		fmt.Fprint(w, "Welcome to example.com")
	})
	server.RegisterFunc("example.org", func(w *gemini.ResponseWriter, r *gemini.Request) {
		fmt.Fprint(w, "Welcome to example.org")
	})
	server.RegisterFunc("http://example.net", func(w *gemini.ResponseWriter, r *gemini.Request) {
		fmt.Fprint(w, "Proxied content from http://example.net")
	})

To start the server, call ListenAndServe:

	err := server.ListenAndServe()
	if err != nil {
		// handle error
	}
*/
package gemini