From 629e6a0e0c3a24f35888036f957ee3a631e62816 Mon Sep 17 00:00:00 2001 From: tjp Date: Mon, 13 Nov 2023 07:27:36 -0700 Subject: add nex protocol support --- nex/client.go | 61 ++++++++++++++++++++++++++++++++++++++ nex/protocol.go | 23 +++++++++++++++ nex/request.go | 28 ++++++++++++++++++ nex/response.go | 18 ++++++++++++ nex/serve.go | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 221 insertions(+) create mode 100644 nex/client.go create mode 100644 nex/protocol.go create mode 100644 nex/request.go create mode 100644 nex/response.go create mode 100644 nex/serve.go (limited to 'nex') diff --git a/nex/client.go b/nex/client.go new file mode 100644 index 0000000..5f53746 --- /dev/null +++ b/nex/client.go @@ -0,0 +1,61 @@ +package nex + +import ( + "bytes" + "errors" + "io" + "net" + neturl "net/url" + + "tildegit.org/tjp/sliderule/internal/types" +) + +// Client is used for sending nex requests and reading responses. +// +// It carries no state and is reusable simultaneously by multiple goroutines. +// +// The zero value is immediately usable. +type Client struct{} + +// RoundTrip sends a single nex request and returns its response. +func (c Client) RoundTrip(request *types.Request) (*types.Response, error) { + if request.Scheme != "nex" && request.Scheme != "" { + return nil, errors.New("non-nex protocols not supported") + } + + host := request.Host + if _, port, _ := net.SplitHostPort(host); port == "" { + host = net.JoinHostPort(host, "1900") + } + + conn, err := net.Dial("tcp", host) + if err != nil { + return nil, err + } + defer conn.Close() + + request.RemoteAddr = conn.RemoteAddr() + request.TLSState = nil + + if _, err := conn.Write([]byte(request.Path + "\n")); err != nil { + return nil, err + } + + response, err := io.ReadAll(conn) + if err != nil { + return nil, err + } + + return &types.Response{Body: bytes.NewBuffer(response)}, nil +} + +// Fetch builds and sends a nex request, and returns the response. +func (c Client) Fetch(url string) (*types.Response, error) { + u, err := neturl.Parse(url) + if err != nil { + return nil, err + } + return c.RoundTrip(&types.Request{URL: u}) +} + +func (c Client) IsRedirect(response *types.Response) bool { return false } diff --git a/nex/protocol.go b/nex/protocol.go new file mode 100644 index 0000000..0fad3a2 --- /dev/null +++ b/nex/protocol.go @@ -0,0 +1,23 @@ +package nex + +import ( + "io" + "net/url" + + "tildegit.org/tjp/sliderule/internal/types" +) + +type proto struct{} + +func (p proto) TemporaryRedirect(u *url.URL) *types.Response { return nil } +func (p proto) PermanentRedirect(u *url.URL) *types.Response { return nil } + +func (p proto) TemporaryServerError(err error) *types.Response { return StringResponse(err.Error()) } +func (p proto) PermanentServerError(err error) *types.Response { return StringResponse(err.Error()) } +func (p proto) CGIFailure(err error) *types.Response { return StringResponse(err.Error()) } + +func (p proto) Success(_ string, body io.Reader) *types.Response { return Response(body) } + +func (p proto) ParseResponse(input io.Reader) (*types.Response, error) { return Response(input), nil } + +var ServerProtocol types.ServerProtocol = proto{} diff --git a/nex/request.go b/nex/request.go new file mode 100644 index 0000000..290d55d --- /dev/null +++ b/nex/request.go @@ -0,0 +1,28 @@ +package nex + +import ( + "bufio" + "io" + "net/url" + "strings" + + "tildegit.org/tjp/sliderule/internal/types" +) + +// ParseRequest reads a nex request from an io.Reader. +func ParseRequest(rdr io.Reader) (*types.Request, error) { + line, err := bufio.NewReader(rdr).ReadString('\n') + if err != nil { + return nil, err + } + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + + return &types.Request{ + URL: &url.URL{ + Scheme: "nex", + Path: line, + OmitHost: true, + }, + }, nil +} diff --git a/nex/response.go b/nex/response.go new file mode 100644 index 0000000..165f161 --- /dev/null +++ b/nex/response.go @@ -0,0 +1,18 @@ +package nex + +import ( + "bytes" + "io" + + "tildegit.org/tjp/sliderule/internal/types" +) + +// Response builds a nex Response from an io.Reader. +func Response(body io.Reader) *types.Response { + return &types.Response{Body: body} +} + +// StringResponse builds a nex Response from a string. +func StringResponse(body string) *types.Response { + return Response(bytes.NewBufferString(body)) +} diff --git a/nex/serve.go b/nex/serve.go new file mode 100644 index 0000000..7e103e3 --- /dev/null +++ b/nex/serve.go @@ -0,0 +1,91 @@ +package nex + +import ( + "bytes" + "context" + "crypto/tls" + "fmt" + "io" + "net" + + "tildegit.org/tjp/sliderule/internal" + "tildegit.org/tjp/sliderule/internal/types" + "tildegit.org/tjp/sliderule/logging" +) + +type nexServer struct { + internal.Server + handler types.Handler +} + +func (ns nexServer) Protocol() string { return "NEX" } + +// NewServer builds a new nex server +func NewServer( + ctx context.Context, + hostname string, + network string, + address string, + handler types.Handler, + baseLog logging.Logger, +) (types.Server, error) { + ns := &nexServer{handler: handler} + + hostname = internal.JoinDefaultPort(hostname, "1900") + address = internal.JoinDefaultPort(address, "1900") + + var err error + ns.Server, err = internal.NewServer(ctx, hostname, network, address, baseLog, ns.handleConn) + if err != nil { + return nil, err + } + + return ns, err +} + +func NewTLSServer( + ctx context.Context, + hostname string, + network string, + address string, + handler types.Handler, + baseLog logging.Logger, + tlsConfig *tls.Config, +) (types.Server, error) { + ns, err := NewServer(ctx, hostname, network, address, handler, baseLog) + if err != nil { + return nil, err + } + + ns.(*nexServer).Listener = tls.NewListener(ns.(*nexServer).Listener, tlsConfig) + return ns, nil +} + +func (ns *nexServer) handleConn(conn net.Conn) { + request, err := ParseRequest(conn) + if err != nil { + _, _ = fmt.Fprint(conn, err.Error()+"\n") + } + + request.Server = ns + request.RemoteAddr = conn.RemoteAddr() + + if tlsconn, ok := conn.(*tls.Conn); ok { + state := tlsconn.ConnectionState() + request.TLSState = &state + } + + defer func() { + if r := recover(); r != nil { + _ = ns.LogError("msg", "panic in handler", "err", r) + _, _ = fmt.Fprint(conn, "Error handling request.\n") + } + }() + response := ns.handler.Handle(ns.Ctx, request) + if response == nil { + response = Response(bytes.NewBufferString("Document not found.")) + } + + defer response.Close() + _, _ = io.Copy(conn, response.Body) +} -- cgit v1.2.3