2020-10-24 19:15:32 +00:00
|
|
|
package gemini
|
2020-09-25 23:06:56 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
|
|
|
"crypto/tls"
|
2020-09-28 05:10:36 +00:00
|
|
|
"crypto/x509"
|
2020-09-25 23:06:56 +00:00
|
|
|
"log"
|
|
|
|
"net"
|
|
|
|
"net/url"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
// Server is a Gemini server.
|
|
|
|
type Server struct {
|
|
|
|
// Addr specifies the address that the server should listen on.
|
|
|
|
// If Addr is empty, the server will listen on the address ":1965".
|
|
|
|
Addr string
|
|
|
|
|
2020-11-01 01:07:02 +00:00
|
|
|
// ReadTimeout is the maximum duration for reading a request.
|
|
|
|
ReadTimeout time.Duration
|
|
|
|
|
|
|
|
// WriteTimeout is the maximum duration before timing out
|
|
|
|
// writes of the response.
|
|
|
|
WriteTimeout time.Duration
|
|
|
|
|
2020-11-01 04:05:00 +00:00
|
|
|
// Certificates contains the certificates used by the server.
|
|
|
|
Certificates CertificateStore
|
|
|
|
|
2020-10-28 18:59:45 +00:00
|
|
|
// CreateCertificate, if not nil, will be called to create a new certificate
|
2020-10-31 19:38:39 +00:00
|
|
|
// if the current one is expired or missing.
|
2020-10-28 18:59:45 +00:00
|
|
|
CreateCertificate func(hostname string) (tls.Certificate, error)
|
2020-09-25 23:06:56 +00:00
|
|
|
|
2020-10-21 20:28:50 +00:00
|
|
|
// registered responders
|
|
|
|
responders map[responderKey]Responder
|
2020-10-31 19:38:39 +00:00
|
|
|
hosts map[string]bool
|
2020-10-11 21:53:22 +00:00
|
|
|
}
|
|
|
|
|
2020-10-21 20:28:50 +00:00
|
|
|
type responderKey struct {
|
2020-10-21 17:22:26 +00:00
|
|
|
scheme string
|
|
|
|
hostname string
|
2020-10-12 17:50:07 +00:00
|
|
|
}
|
|
|
|
|
2020-10-21 20:28:50 +00:00
|
|
|
// Register registers a responder for the given pattern.
|
2020-10-28 20:02:04 +00:00
|
|
|
//
|
2020-11-01 00:32:38 +00:00
|
|
|
// Patterns must be in the form of "hostname" or "scheme://hostname".
|
|
|
|
// If no scheme is specified, a scheme of "gemini://" is implied.
|
|
|
|
// Wildcard patterns are supported (e.g. "*.example.com").
|
2020-10-21 20:28:50 +00:00
|
|
|
func (s *Server) Register(pattern string, responder Responder) {
|
2020-10-21 17:22:26 +00:00
|
|
|
if pattern == "" {
|
2020-10-24 19:15:32 +00:00
|
|
|
panic("gemini: invalid pattern")
|
2020-10-11 22:57:04 +00:00
|
|
|
}
|
2020-10-21 20:28:50 +00:00
|
|
|
if responder == nil {
|
2020-10-24 19:15:32 +00:00
|
|
|
panic("gemini: nil responder")
|
2020-10-11 22:57:04 +00:00
|
|
|
}
|
2020-10-21 20:28:50 +00:00
|
|
|
if s.responders == nil {
|
|
|
|
s.responders = map[responderKey]Responder{}
|
2020-10-31 19:38:39 +00:00
|
|
|
s.hosts = map[string]bool{}
|
2020-10-12 17:50:07 +00:00
|
|
|
}
|
|
|
|
|
2020-10-21 17:22:26 +00:00
|
|
|
split := strings.SplitN(pattern, "://", 2)
|
2020-10-21 20:28:50 +00:00
|
|
|
var key responderKey
|
2020-10-21 17:22:26 +00:00
|
|
|
if len(split) == 2 {
|
|
|
|
key.scheme = split[0]
|
|
|
|
key.hostname = split[1]
|
|
|
|
} else {
|
|
|
|
key.scheme = "gemini"
|
|
|
|
key.hostname = split[0]
|
|
|
|
}
|
2020-10-11 21:53:22 +00:00
|
|
|
|
2020-10-28 18:59:45 +00:00
|
|
|
if _, ok := s.responders[key]; ok {
|
|
|
|
panic("gemini: multiple registrations for " + pattern)
|
|
|
|
}
|
2020-10-21 20:28:50 +00:00
|
|
|
s.responders[key] = responder
|
2020-10-31 19:38:39 +00:00
|
|
|
s.hosts[key.hostname] = true
|
2020-10-11 21:53:22 +00:00
|
|
|
}
|
|
|
|
|
2020-10-21 20:28:50 +00:00
|
|
|
// RegisterFunc registers a responder function for the given pattern.
|
|
|
|
func (s *Server) RegisterFunc(pattern string, responder func(*ResponseWriter, *Request)) {
|
|
|
|
s.Register(pattern, ResponderFunc(responder))
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ListenAndServe listens for requests at the server's configured address.
|
|
|
|
func (s *Server) ListenAndServe() error {
|
|
|
|
addr := s.Addr
|
|
|
|
if addr == "" {
|
|
|
|
addr = ":1965"
|
|
|
|
}
|
|
|
|
|
|
|
|
ln, err := net.Listen("tcp", addr)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer ln.Close()
|
|
|
|
|
2020-10-28 18:59:45 +00:00
|
|
|
return s.Serve(tls.NewListener(ln, &tls.Config{
|
|
|
|
ClientAuth: tls.RequestClientCert,
|
|
|
|
MinVersion: tls.VersionTLS12,
|
|
|
|
GetCertificate: s.getCertificate,
|
|
|
|
}))
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Serve listens for requests on the provided listener.
|
|
|
|
func (s *Server) Serve(l net.Listener) error {
|
|
|
|
var tempDelay time.Duration // how long to sleep on accept failure
|
|
|
|
|
|
|
|
for {
|
|
|
|
rw, err := l.Accept()
|
|
|
|
if err != nil {
|
|
|
|
// If this is a temporary error, sleep
|
|
|
|
if ne, ok := err.(net.Error); ok && ne.Temporary() {
|
|
|
|
if tempDelay == 0 {
|
|
|
|
tempDelay = 5 * time.Millisecond
|
|
|
|
} else {
|
|
|
|
tempDelay *= 2
|
|
|
|
}
|
|
|
|
if max := 1 * time.Second; tempDelay > max {
|
|
|
|
tempDelay = max
|
|
|
|
}
|
2020-10-24 19:15:32 +00:00
|
|
|
log.Printf("gemini: Accept error: %v; retrying in %v", err, tempDelay)
|
2020-09-25 23:06:56 +00:00
|
|
|
time.Sleep(tempDelay)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, return the error
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
tempDelay = 0
|
|
|
|
go s.respond(rw)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-28 18:59:45 +00:00
|
|
|
func (s *Server) getCertificate(h *tls.ClientHelloInfo) (*tls.Certificate, error) {
|
2020-10-31 20:33:56 +00:00
|
|
|
cert, err := s.getCertificateFor(h.ServerName)
|
|
|
|
if err != nil {
|
|
|
|
// Try wildcard
|
2020-10-31 19:11:05 +00:00
|
|
|
wildcard := strings.SplitN(h.ServerName, ".", 2)
|
|
|
|
if len(wildcard) == 2 {
|
2020-10-31 20:33:56 +00:00
|
|
|
cert, err = s.getCertificateFor("*." + wildcard[1])
|
2020-10-31 19:11:05 +00:00
|
|
|
}
|
|
|
|
}
|
2020-10-31 20:33:56 +00:00
|
|
|
return cert, err
|
|
|
|
}
|
2020-10-31 19:11:05 +00:00
|
|
|
|
2020-10-31 20:33:56 +00:00
|
|
|
func (s *Server) getCertificateFor(hostname string) (*tls.Certificate, error) {
|
|
|
|
if _, ok := s.hosts[hostname]; !ok {
|
2020-11-01 02:34:51 +00:00
|
|
|
return nil, ErrCertificateNotFound
|
2020-10-31 20:33:56 +00:00
|
|
|
}
|
|
|
|
cert, err := s.Certificates.Lookup(hostname)
|
2020-10-31 19:38:39 +00:00
|
|
|
|
2020-10-31 20:33:56 +00:00
|
|
|
switch err {
|
2020-10-31 20:45:38 +00:00
|
|
|
case ErrCertificateNotFound, ErrCertificateExpired:
|
2020-10-28 18:59:45 +00:00
|
|
|
if s.CreateCertificate != nil {
|
2020-10-31 20:33:56 +00:00
|
|
|
cert, err := s.CreateCertificate(hostname)
|
2020-10-28 18:59:45 +00:00
|
|
|
if err == nil {
|
2020-10-31 20:33:56 +00:00
|
|
|
s.Certificates.Add(hostname, cert)
|
2020-10-28 18:59:45 +00:00
|
|
|
}
|
|
|
|
return &cert, err
|
|
|
|
}
|
|
|
|
}
|
2020-10-31 19:11:05 +00:00
|
|
|
|
2020-10-28 18:59:45 +00:00
|
|
|
return cert, err
|
|
|
|
}
|
|
|
|
|
2020-10-21 20:28:50 +00:00
|
|
|
// respond responds to a connection.
|
|
|
|
func (s *Server) respond(conn net.Conn) {
|
2020-11-01 01:07:02 +00:00
|
|
|
if d := s.ReadTimeout; d != 0 {
|
|
|
|
conn.SetReadDeadline(time.Now().Add(d))
|
|
|
|
}
|
|
|
|
if d := s.WriteTimeout; d != 0 {
|
|
|
|
conn.SetWriteDeadline(time.Now().Add(d))
|
|
|
|
}
|
|
|
|
|
2020-10-21 20:28:50 +00:00
|
|
|
r := bufio.NewReader(conn)
|
|
|
|
w := newResponseWriter(conn)
|
|
|
|
// Read requested URL
|
|
|
|
rawurl, err := r.ReadString('\r')
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// Read terminating line feed
|
|
|
|
if b, err := r.ReadByte(); err != nil {
|
|
|
|
return
|
|
|
|
} else if b != '\n' {
|
2020-10-31 20:45:38 +00:00
|
|
|
w.WriteStatus(StatusBadRequest)
|
2020-10-21 20:28:50 +00:00
|
|
|
}
|
|
|
|
// Trim carriage return
|
|
|
|
rawurl = rawurl[:len(rawurl)-1]
|
|
|
|
// Ensure URL is valid
|
|
|
|
if len(rawurl) > 1024 {
|
2020-10-31 20:45:38 +00:00
|
|
|
w.WriteStatus(StatusBadRequest)
|
2020-10-21 20:28:50 +00:00
|
|
|
} else if url, err := url.Parse(rawurl); err != nil || url.User != nil {
|
|
|
|
// Note that we return an error status if User is specified in the URL
|
2020-10-31 20:45:38 +00:00
|
|
|
w.WriteStatus(StatusBadRequest)
|
2020-10-21 20:28:50 +00:00
|
|
|
} else {
|
|
|
|
// If no scheme is specified, assume a default scheme of gemini://
|
|
|
|
if url.Scheme == "" {
|
|
|
|
url.Scheme = "gemini"
|
|
|
|
}
|
|
|
|
req := &Request{
|
|
|
|
URL: url,
|
|
|
|
RemoteAddr: conn.RemoteAddr(),
|
|
|
|
TLS: conn.(*tls.Conn).ConnectionState(),
|
|
|
|
}
|
2020-10-27 17:30:35 +00:00
|
|
|
resp := s.responder(req)
|
|
|
|
if resp != nil {
|
|
|
|
resp.Respond(w, req)
|
|
|
|
} else {
|
|
|
|
w.WriteStatus(StatusNotFound)
|
|
|
|
}
|
2020-10-21 20:28:50 +00:00
|
|
|
}
|
|
|
|
w.b.Flush()
|
|
|
|
conn.Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) responder(r *Request) Responder {
|
2020-10-31 19:11:05 +00:00
|
|
|
if h, ok := s.responders[responderKey{r.URL.Scheme, r.URL.Hostname()}]; ok {
|
2020-10-21 20:28:50 +00:00
|
|
|
return h
|
|
|
|
}
|
|
|
|
wildcard := strings.SplitN(r.URL.Hostname(), ".", 2)
|
|
|
|
if len(wildcard) == 2 {
|
2020-10-31 19:11:05 +00:00
|
|
|
if h, ok := s.responders[responderKey{r.URL.Scheme, "*." + wildcard[1]}]; ok {
|
2020-10-21 20:28:50 +00:00
|
|
|
return h
|
|
|
|
}
|
|
|
|
}
|
2020-10-27 17:30:35 +00:00
|
|
|
return nil
|
2020-10-21 20:28:50 +00:00
|
|
|
}
|
|
|
|
|
2020-09-25 23:06:56 +00:00
|
|
|
// ResponseWriter is used by a Gemini handler to construct a Gemini response.
|
|
|
|
type ResponseWriter struct {
|
2020-10-14 01:00:07 +00:00
|
|
|
b *bufio.Writer
|
2020-09-25 23:06:56 +00:00
|
|
|
bodyAllowed bool
|
2020-09-28 01:53:58 +00:00
|
|
|
wroteHeader bool
|
|
|
|
mimetype string
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func newResponseWriter(conn net.Conn) *ResponseWriter {
|
|
|
|
return &ResponseWriter{
|
2020-10-14 01:00:07 +00:00
|
|
|
b: bufio.NewWriter(conn),
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// WriteHeader writes the response header.
|
2020-09-28 01:53:58 +00:00
|
|
|
// If the header has already been written, WriteHeader does nothing.
|
2020-09-25 23:06:56 +00:00
|
|
|
//
|
|
|
|
// Meta contains more information related to the response status.
|
|
|
|
// For successful responses, Meta should contain the mimetype of the response.
|
|
|
|
// For failure responses, Meta should contain a short description of the failure.
|
|
|
|
// Meta should not be longer than 1024 bytes.
|
2020-10-27 17:30:35 +00:00
|
|
|
func (w *ResponseWriter) WriteHeader(status Status, meta string) {
|
2020-10-14 01:00:07 +00:00
|
|
|
if w.wroteHeader {
|
2020-09-28 01:53:58 +00:00
|
|
|
return
|
|
|
|
}
|
2020-10-27 17:30:35 +00:00
|
|
|
w.b.WriteString(strconv.Itoa(int(status)))
|
2020-10-14 01:00:07 +00:00
|
|
|
w.b.WriteByte(' ')
|
|
|
|
w.b.WriteString(meta)
|
|
|
|
w.b.Write(crlf)
|
2020-09-25 23:06:56 +00:00
|
|
|
|
|
|
|
// Only allow body to be written on successful status codes.
|
2020-10-27 17:30:35 +00:00
|
|
|
if status.Class() == StatusClassSuccess {
|
2020-10-14 01:00:07 +00:00
|
|
|
w.bodyAllowed = true
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
2020-10-14 01:00:07 +00:00
|
|
|
w.wroteHeader = true
|
2020-09-28 01:53:58 +00:00
|
|
|
}
|
|
|
|
|
2020-10-27 17:30:35 +00:00
|
|
|
// WriteStatus writes the response header with the given status code.
|
2020-11-01 00:32:38 +00:00
|
|
|
//
|
|
|
|
// WriteStatus is equivalent to WriteHeader(status, status.Message())
|
2020-10-27 17:30:35 +00:00
|
|
|
func (w *ResponseWriter) WriteStatus(status Status) {
|
|
|
|
w.WriteHeader(status, status.Message())
|
|
|
|
}
|
|
|
|
|
2020-09-28 01:53:58 +00:00
|
|
|
// SetMimetype sets the mimetype that will be written for a successful response.
|
|
|
|
// If the mimetype is not set, it will default to "text/gemini".
|
2020-10-14 01:00:07 +00:00
|
|
|
func (w *ResponseWriter) SetMimetype(mimetype string) {
|
|
|
|
w.mimetype = mimetype
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Write writes the response body.
|
|
|
|
// If the response status does not allow for a response body, Write returns
|
|
|
|
// ErrBodyNotAllowed.
|
2020-09-28 01:53:58 +00:00
|
|
|
//
|
2020-11-01 00:32:38 +00:00
|
|
|
// If the response header has not yet been written, Write calls WriteHeader
|
|
|
|
// with StatusSuccess and the mimetype set in SetMimetype.
|
2020-10-14 01:00:07 +00:00
|
|
|
func (w *ResponseWriter) Write(b []byte) (int, error) {
|
|
|
|
if !w.wroteHeader {
|
|
|
|
mimetype := w.mimetype
|
2020-09-28 02:03:09 +00:00
|
|
|
if mimetype == "" {
|
|
|
|
mimetype = "text/gemini"
|
2020-09-28 01:53:58 +00:00
|
|
|
}
|
2020-10-14 01:00:07 +00:00
|
|
|
w.WriteHeader(StatusSuccess, mimetype)
|
2020-09-28 01:53:58 +00:00
|
|
|
}
|
2020-10-14 01:00:07 +00:00
|
|
|
if !w.bodyAllowed {
|
2020-09-25 23:06:56 +00:00
|
|
|
return 0, ErrBodyNotAllowed
|
|
|
|
}
|
2020-10-14 01:00:07 +00:00
|
|
|
return w.b.Write(b)
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
|
|
|
|
2020-10-21 20:28:50 +00:00
|
|
|
// A Responder responds to a Gemini request.
|
|
|
|
type Responder interface {
|
|
|
|
// Respond accepts a Request and constructs a Response.
|
|
|
|
Respond(*ResponseWriter, *Request)
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|
|
|
|
|
2020-11-01 19:35:03 +00:00
|
|
|
// ResponderFunc is a wrapper around a bare function that implements Responder.
|
|
|
|
type ResponderFunc func(*ResponseWriter, *Request)
|
|
|
|
|
|
|
|
func (f ResponderFunc) Respond(w *ResponseWriter, r *Request) {
|
|
|
|
f(w, r)
|
2020-09-28 06:05:37 +00:00
|
|
|
}
|
|
|
|
|
2020-11-01 19:35:03 +00:00
|
|
|
// Input returns the request query.
|
|
|
|
// If the query is invalid or no query is provided, ok will be false.
|
|
|
|
//
|
|
|
|
// Example:
|
|
|
|
//
|
|
|
|
// input, ok := gemini.Input(req)
|
|
|
|
// if !ok {
|
|
|
|
// w.WriteHeader(gemini.StatusInput, "Prompt")
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
// // ...
|
|
|
|
//
|
|
|
|
func Input(r *Request) (query string, ok bool) {
|
2020-10-21 21:34:07 +00:00
|
|
|
if r.URL.ForceQuery || r.URL.RawQuery != "" {
|
2020-10-28 03:35:22 +00:00
|
|
|
query, err := url.QueryUnescape(r.URL.RawQuery)
|
|
|
|
return query, err == nil
|
2020-09-28 06:05:37 +00:00
|
|
|
}
|
2020-10-21 21:34:07 +00:00
|
|
|
return "", false
|
2020-09-28 06:05:37 +00:00
|
|
|
}
|
|
|
|
|
2020-11-01 19:35:03 +00:00
|
|
|
// Certificate returns the request certificate.
|
|
|
|
// It returns nil if no certificate was provided.
|
|
|
|
//
|
|
|
|
// Example:
|
|
|
|
//
|
|
|
|
// cert := gemini.Certificate(req)
|
|
|
|
// if cert == nil {
|
|
|
|
// w.WriteStatus(gemini.StatusCertificateRequired)
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
// // ...
|
|
|
|
//
|
|
|
|
func Certificate(r *Request) *x509.Certificate {
|
2020-10-14 00:22:12 +00:00
|
|
|
if len(r.TLS.PeerCertificates) == 0 {
|
2020-11-01 19:35:03 +00:00
|
|
|
return nil
|
2020-09-28 05:10:36 +00:00
|
|
|
}
|
2020-11-01 19:35:03 +00:00
|
|
|
return r.TLS.PeerCertificates[0]
|
2020-09-25 23:06:56 +00:00
|
|
|
}
|