152 lines
3.3 KiB
Go
152 lines
3.3 KiB
Go
package gemini
|
|
|
|
import (
|
|
"crypto/tls"
|
|
"crypto/x509"
|
|
"net"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
// Server is a Gemini server.
|
|
type Server struct {
|
|
Addr string
|
|
TLSConfig tls.Config
|
|
Handler Handler
|
|
}
|
|
|
|
// 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()
|
|
|
|
tlsListener := tls.NewListener(ln, &s.TLSConfig)
|
|
return s.Serve(tlsListener)
|
|
}
|
|
|
|
// Serve listens for requests on the provided listener.
|
|
func (s *Server) Serve(ln net.Listener) error {
|
|
for {
|
|
rw, err := ln.Accept()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var resp *Response
|
|
|
|
if rawurl, err := readLine(rw); err != nil {
|
|
resp = &Response{
|
|
Status: StatusBadRequest,
|
|
Meta: "Bad request",
|
|
}
|
|
} else if len(rawurl) > 1024 {
|
|
resp = &Response{
|
|
Status: StatusBadRequest,
|
|
Meta: "URL exceeds 1024 bytes",
|
|
}
|
|
} else if url, err := url.Parse(rawurl); err != nil {
|
|
resp = &Response{
|
|
Status: StatusBadRequest,
|
|
Meta: "Invalid URL",
|
|
}
|
|
} else {
|
|
// Gather information about the request
|
|
reqInfo := &RequestInfo{
|
|
URL: url,
|
|
Certificates: rw.(*tls.Conn).ConnectionState().PeerCertificates,
|
|
RemoteAddr: rw.RemoteAddr(),
|
|
}
|
|
resp = s.Handler.Serve(reqInfo)
|
|
}
|
|
|
|
resp.Write(rw)
|
|
rw.Close()
|
|
}
|
|
}
|
|
|
|
// RequestInfo contains information about a request.
|
|
type RequestInfo struct {
|
|
URL *url.URL // the requested URL
|
|
Certificates []*x509.Certificate // client certificates
|
|
RemoteAddr net.Addr // client remote address
|
|
}
|
|
|
|
// A Handler responds to a Gemini request.
|
|
type Handler interface {
|
|
// Serve accepts a Request and returns a Response.
|
|
Serve(*RequestInfo) *Response
|
|
}
|
|
|
|
// Mux is a Gemini request multiplexer.
|
|
// It matches the URL of each incoming request against a list of registered
|
|
// patterns and calls the handler for the pattern that most closesly matches
|
|
// the URL.
|
|
type Mux struct {
|
|
entries []muxEntry
|
|
}
|
|
|
|
type muxEntry struct {
|
|
scheme string
|
|
host string
|
|
path string
|
|
handler Handler
|
|
}
|
|
|
|
func (m *Mux) match(url *url.URL) Handler {
|
|
for _, e := range m.entries {
|
|
if (e.scheme == "" || url.Scheme == e.scheme) &&
|
|
(e.host == "" || url.Host == e.host) &&
|
|
strings.HasPrefix(url.Path, e.path) {
|
|
return e.handler
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Handle registers a Handler for the given pattern.
|
|
func (m *Mux) Handle(pattern string, handler Handler) {
|
|
url, err := url.Parse(pattern)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
m.entries = append(m.entries, muxEntry{
|
|
url.Scheme,
|
|
url.Host,
|
|
url.Path,
|
|
handler,
|
|
})
|
|
}
|
|
|
|
// HandleFunc registers a HandlerFunc for the given pattern.
|
|
func (m *Mux) HandleFunc(pattern string, handlerFunc func(req *RequestInfo) *Response) {
|
|
handler := HandlerFunc(handlerFunc)
|
|
m.Handle(pattern, handler)
|
|
}
|
|
|
|
// Serve responds to the request with the appropriate handler.
|
|
func (m *Mux) Serve(req *RequestInfo) *Response {
|
|
h := m.match(req.URL)
|
|
if h == nil {
|
|
return &Response{
|
|
Status: StatusNotFound,
|
|
Meta: "Not found",
|
|
}
|
|
}
|
|
return h.Serve(req)
|
|
}
|
|
|
|
// A wrapper around a bare function that implements Handler.
|
|
type HandlerFunc func(req *RequestInfo) *Response
|
|
|
|
func (f HandlerFunc) Serve(req *RequestInfo) *Response {
|
|
return f(req)
|
|
}
|