mirror of
https://git.sr.ht/~adnano/go-gemini
synced 2024-09-19 23:01:37 +02:00
128 lines
3.0 KiB
Go
128 lines
3.0 KiB
Go
// Package gemini implements the Gemini protocol.
|
|
package gemini
|
|
|
|
import (
|
|
"crypto/tls"
|
|
"errors"
|
|
"io"
|
|
"net/url"
|
|
"strconv"
|
|
)
|
|
|
|
// Status codes.
|
|
const (
|
|
StatusInput = 10
|
|
StatusSensitiveInput = 11
|
|
StatusSuccess = 20
|
|
StatusRedirectTemporary = 30
|
|
StatusRedirectPermanent = 31
|
|
StatusTemporaryFailure = 40
|
|
StatusServerUnavailable = 41
|
|
StatusCGIError = 42
|
|
StatusProxyError = 43
|
|
StatusSlowDown = 44
|
|
StatusPermanentFailure = 50
|
|
StatusNotFound = 51
|
|
StatusGone = 52
|
|
StatusProxyRequestRefused = 53
|
|
StatusBadRequest = 59
|
|
StatusClientCertificateRequired = 60
|
|
StatusCertificateNotAuthorised = 61
|
|
StatusCertificateNotValid = 62
|
|
)
|
|
|
|
// Status code categories.
|
|
const (
|
|
StatusClassInput = 1
|
|
StatusClassSuccess = 2
|
|
StatusClassRedirect = 3
|
|
StatusClassTemporaryFailure = 4
|
|
StatusClassPermanentFailure = 5
|
|
StatusClassClientCertificateRequired = 6
|
|
)
|
|
|
|
// Errors.
|
|
var (
|
|
ErrProtocol = errors.New("Protocol error")
|
|
ErrInvalidURL = errors.New("Invalid URL")
|
|
)
|
|
|
|
// Request is a Gemini request.
|
|
//
|
|
// A Request can optionally be configured with a client certificate. Example:
|
|
//
|
|
// req := NewRequest(url)
|
|
// cert, err := tls.LoadX509KeyPair("client.crt", "client.key")
|
|
// if err != nil {
|
|
// panic(err)
|
|
// }
|
|
// req.Certificates = append(req.Certificates, cert)
|
|
//
|
|
type Request struct {
|
|
Host string // host or host:port
|
|
URL *url.URL // the requested URL
|
|
Certificates []tls.Certificate // client certificates
|
|
}
|
|
|
|
// NewRequest returns a new request. The host is inferred from the provided url.
|
|
func NewRequest(rawurl string) (*Request, error) {
|
|
u, err := url.Parse(rawurl)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Request{
|
|
Host: u.Host,
|
|
URL: u,
|
|
}, nil
|
|
}
|
|
|
|
// NewProxyRequest returns a new request using the provided host.
|
|
func NewProxyRequest(host, rawurl string) (*Request, error) {
|
|
u, err := url.Parse(rawurl)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Request{
|
|
Host: host,
|
|
URL: u,
|
|
}, nil
|
|
}
|
|
|
|
// Write writes the Gemini request to the provided io.Writer.
|
|
func (r *Request) Write(w io.Writer) error {
|
|
url := r.URL.String()
|
|
// UserInfo is invalid
|
|
if r.URL.User != nil || len(url) > 1024 {
|
|
return ErrInvalidURL
|
|
}
|
|
request := url + "\r\n"
|
|
_, err := w.Write([]byte(request))
|
|
return err
|
|
}
|
|
|
|
// Response is a Gemini response.
|
|
type Response struct {
|
|
Status int
|
|
Meta string
|
|
Body []byte
|
|
}
|
|
|
|
// Write writes the Gemini response header and body to the provided io.Writer.
|
|
func (r *Response) Write(w io.Writer) error {
|
|
header := strconv.Itoa(r.Status) + " " + r.Meta + "\r\n"
|
|
if _, err := w.Write([]byte(header)); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Only write the response body on success
|
|
if r.Status/10 == StatusClassSuccess {
|
|
if _, err := w.Write(r.Body); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|