197 lines
3.3 KiB
Go
197 lines
3.3 KiB
Go
package gemini
|
|
|
|
import (
|
|
"bufio"
|
|
"crypto/tls"
|
|
"net"
|
|
"net/url"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
const (
|
|
StatusSuccess = 20
|
|
StatusTemporaryFail = 40
|
|
StatusPermanentFail = 50
|
|
StatusNotFound = 51
|
|
StatusBadRequest = 59
|
|
)
|
|
|
|
type Handler interface {
|
|
ServeGemini(ResponseWriter, *Request)
|
|
}
|
|
|
|
type HandlerFunc func(ResponseWriter, *Request)
|
|
|
|
func (f HandlerFunc) ServeGemini(w ResponseWriter, r *Request) {
|
|
f(w, r)
|
|
}
|
|
|
|
type ServeMux struct {
|
|
mu sync.RWMutex
|
|
handlers map[string]Handler
|
|
}
|
|
|
|
func NewServeMux() *ServeMux {
|
|
return &ServeMux{
|
|
handlers: make(map[string]Handler),
|
|
}
|
|
}
|
|
|
|
func (m *ServeMux) Handle(pattern string, h Handler) {
|
|
m.mu.Lock()
|
|
m.handlers[pattern] = h
|
|
m.mu.Unlock()
|
|
}
|
|
|
|
func (m *ServeMux) HandleFunc(pattern string, f func(ResponseWriter, *Request)) {
|
|
m.Handle(pattern, HandlerFunc(f))
|
|
}
|
|
|
|
func (m *ServeMux) ServeGemini(w ResponseWriter, r *Request) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
path := r.URL.Path
|
|
|
|
for pattern, handler := range m.handlers {
|
|
if strings.HasPrefix(path, pattern) {
|
|
handler.ServeGemini(w, r)
|
|
return
|
|
}
|
|
}
|
|
|
|
w.WriteHeader(StatusNotFound, "not found")
|
|
}
|
|
|
|
var DefaultServeMux = NewServeMux()
|
|
|
|
func Handle(pattern string, h Handler) {
|
|
DefaultServeMux.Handle(pattern, h)
|
|
}
|
|
|
|
func HandleFunc(pattern string, f func(ResponseWriter, *Request)) {
|
|
DefaultServeMux.HandleFunc(pattern, f)
|
|
}
|
|
|
|
type Request struct {
|
|
URL *url.URL
|
|
Conn net.Conn
|
|
}
|
|
|
|
type ResponseWriter interface {
|
|
Write([]byte) (int, error)
|
|
WriteHeader(status int, meta string)
|
|
}
|
|
|
|
type response struct {
|
|
conn net.Conn
|
|
wroteHeader bool
|
|
}
|
|
|
|
func (r *response) WriteHeader(status int, meta string) {
|
|
if r.wroteHeader {
|
|
return
|
|
}
|
|
r.conn.Write([]byte(
|
|
strings.TrimSpace(
|
|
strings.Join([]string{
|
|
strings.TrimSpace(
|
|
strings.Join([]string{
|
|
string(rune(status/10 + '0')),
|
|
string(rune(status%10 + '0')),
|
|
}, ""),
|
|
),
|
|
meta,
|
|
}, " "),
|
|
) + "\r\n"))
|
|
r.wroteHeader = true
|
|
}
|
|
|
|
func (r *response) Write(b []byte) (int, error) {
|
|
if !r.wroteHeader {
|
|
r.WriteHeader(StatusSuccess, "text/gemini")
|
|
}
|
|
return r.conn.Write(b)
|
|
}
|
|
|
|
type Server struct {
|
|
Addr string
|
|
Handler Handler
|
|
TLSConfig *tls.Config
|
|
}
|
|
|
|
func (s *Server) ListenAndServeTLS(certFile, keyFile string) error {
|
|
handler := s.Handler
|
|
if handler == nil {
|
|
handler = DefaultServeMux
|
|
}
|
|
|
|
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
cfg := s.TLSConfig
|
|
if cfg == nil {
|
|
cfg = &tls.Config{}
|
|
}
|
|
cfg.Certificates = []tls.Certificate{cert}
|
|
|
|
ln, err := tls.Listen("tcp", s.Addr, cfg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for {
|
|
conn, err := ln.Accept()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
go s.serve(conn, handler)
|
|
}
|
|
}
|
|
|
|
func (s *Server) serve(conn net.Conn, handler Handler) {
|
|
defer conn.Close()
|
|
|
|
reader := bufio.NewReader(conn)
|
|
|
|
line, err := reader.ReadString('\n')
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if len(line) > 1026 {
|
|
conn.Write([]byte("59 request too long\r\n"))
|
|
return
|
|
}
|
|
|
|
line = strings.TrimSpace(line)
|
|
|
|
u, err := url.Parse(line)
|
|
if err != nil {
|
|
conn.Write([]byte("59 bad request\r\n"))
|
|
return
|
|
}
|
|
|
|
req := &Request{
|
|
URL: u,
|
|
Conn: conn,
|
|
}
|
|
|
|
rw := &response{
|
|
conn: conn,
|
|
}
|
|
|
|
handler.ServeGemini(rw, req)
|
|
}
|
|
|
|
func ListenAndServeTLS(addr, certFile, keyFile string, h Handler) error {
|
|
s := &Server{
|
|
Addr: addr,
|
|
Handler: h,
|
|
}
|
|
return s.ListenAndServeTLS(certFile, keyFile)
|
|
}
|