193 lines
4.7 KiB
Go
193 lines
4.7 KiB
Go
package gemini
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/tls"
|
|
"errors"
|
|
"io"
|
|
"net"
|
|
neturl "net/url"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"tildegit.org/tjp/sliderule/internal/types"
|
|
)
|
|
|
|
// Client is used for sending gemini requests and parsing gemini responses.
|
|
//
|
|
// It carries no state and is usable and reusable simultaneously by multiple goroutines.
|
|
// The only reason you might create more than one Client is to support separate TLS-cert
|
|
// driven identities.
|
|
//
|
|
// The zero value is a usable Client with no client TLS certificate and which will not
|
|
// follow redirects.
|
|
type Client struct {
|
|
MaxRedirects int
|
|
|
|
tlsConf *tls.Config
|
|
}
|
|
|
|
// NewClient creates a gemini Client with the given TLS configuration and default MaxRedirects.
|
|
func NewClient(tlsConf *tls.Config) Client {
|
|
if tlsConf != nil && !tlsConf.InsecureSkipVerify {
|
|
tlsConf = tlsConf.Clone()
|
|
tlsConf.InsecureSkipVerify = true
|
|
}
|
|
return Client{tlsConf: tlsConf, MaxRedirects: DefaultMaxRedirects}
|
|
}
|
|
|
|
// DefaultMaxRedirects is the number of chained redirects a Client will perform for a
|
|
// single request by default. This can be changed by altering the MaxRedirects field.
|
|
const DefaultMaxRedirects int = 2
|
|
|
|
var ExceededMaxRedirects = errors.New("gemini.Client: exceeded MaxRedirects")
|
|
|
|
// RoundTrip sends a single gemini request to the correct server and returns its response.
|
|
//
|
|
// It also populates the TLSState and RemoteAddr fields on the request - the only field
|
|
// it needs populated beforehand is the URL.
|
|
//
|
|
// This method will not automatically follow redirects or cache permanent failures or
|
|
// redirects.
|
|
func (client Client) RoundTrip(ctx context.Context, request *types.Request) (*types.Response, error) {
|
|
if request.Scheme != "gemini" && request.Scheme != "titan" && request.Scheme != "" {
|
|
return nil, errors.New("non-gemini protocols not supported")
|
|
}
|
|
|
|
host := request.Host
|
|
if _, port, _ := net.SplitHostPort(host); port == "" {
|
|
host = net.JoinHostPort(host, "1965")
|
|
}
|
|
|
|
tlsConf := client.tlsConf
|
|
if tlsConf == nil {
|
|
tlsConf = &tls.Config{InsecureSkipVerify: true}
|
|
}
|
|
|
|
conn, err := (&tls.Dialer{Config: tlsConf}).DialContext(ctx, "tcp", host)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer conn.Close()
|
|
|
|
request.RemoteAddr = conn.RemoteAddr()
|
|
st := conn.(*tls.Conn).ConnectionState()
|
|
request.TLSState = &st
|
|
|
|
destURL := *request.URL
|
|
|
|
var body []byte
|
|
if request.Scheme == "titan" {
|
|
var err error
|
|
if bodyrdr, ok := request.Meta.(io.Reader); ok {
|
|
body, err = io.ReadAll(bodyrdr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := close(request.Meta); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
path, params := pathparams(destURL.Path)
|
|
params["size"] = strconv.Itoa(len(body))
|
|
destURL.Path = assemblepath(path, params)
|
|
} else {
|
|
body = []byte{}
|
|
}
|
|
}
|
|
|
|
if _, err := conn.Write([]byte(destURL.String() + "\r\n")); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if _, err := conn.Write(body); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
response, err := ParseResponse(conn)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// read and store the request body in full or we may miss doing so before
|
|
// closing the connection
|
|
bodybuf, err := io.ReadAll(response.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
response.Body = bytes.NewBuffer(bodybuf)
|
|
response.Request = request
|
|
|
|
return response, nil
|
|
}
|
|
|
|
// Fetch parses a URL string and fetches the gemini resource.
|
|
//
|
|
// It will resolve any redirects along the way, up to client.MaxRedirects.
|
|
func (c Client) Fetch(ctx context.Context, url string) (*types.Response, error) {
|
|
u, err := neturl.Parse(url)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for i := 0; i <= c.MaxRedirects; i += 1 {
|
|
response, err := c.RoundTrip(ctx, &types.Request{URL: u})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !c.IsRedirect(response) {
|
|
return response, nil
|
|
}
|
|
|
|
prev := u
|
|
u, err = neturl.Parse(response.Meta.(string))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
u = prev.ResolveReference(u)
|
|
}
|
|
|
|
return nil, ExceededMaxRedirects
|
|
}
|
|
|
|
func (c Client) IsRedirect(response *types.Response) bool {
|
|
return ResponseCategoryForStatus(response.Status) == ResponseCategoryRedirect
|
|
}
|
|
|
|
func pathparams(basepath string) (string, map[string]string) {
|
|
params := map[string]string{}
|
|
path, paramstr, found := strings.Cut(basepath, ";")
|
|
if !found {
|
|
return path, params
|
|
}
|
|
|
|
for _, pairstr := range strings.Split(paramstr, ";") {
|
|
key, val, found := strings.Cut(pairstr, "=")
|
|
if found {
|
|
params[key] = val
|
|
}
|
|
}
|
|
|
|
return path, params
|
|
}
|
|
|
|
func assemblepath(basepath string, params map[string]string) string {
|
|
path := strings.Builder{}
|
|
_, _ = path.WriteString(basepath)
|
|
for key, val := range params {
|
|
_ = path.WriteByte(';')
|
|
_, _ = path.WriteString(key)
|
|
_ = path.WriteByte('=')
|
|
_, _ = path.WriteString(val)
|
|
}
|
|
return path.String()
|
|
}
|
|
|
|
func close(closer any) error {
|
|
if cl, ok := closer.(io.Closer); ok {
|
|
return cl.Close()
|
|
}
|
|
return nil
|
|
}
|