From f85930d875494c043fc5ac3ddcf843ddfac14ec9 Mon Sep 17 00:00:00 2001 From: tjpcc Date: Mon, 30 Oct 2023 11:57:04 -0600 Subject: spartan support in fs and cgi contribs fixes #17 --- contrib/cgi/spartan.go | 61 +++++++++++++++++++++ contrib/fs/gemini.go | 8 +-- contrib/fs/spartan.go | 145 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 210 insertions(+), 4 deletions(-) create mode 100644 contrib/cgi/spartan.go create mode 100644 contrib/fs/spartan.go (limited to 'contrib') diff --git a/contrib/cgi/spartan.go b/contrib/cgi/spartan.go new file mode 100644 index 0000000..36aaa36 --- /dev/null +++ b/contrib/cgi/spartan.go @@ -0,0 +1,61 @@ +package cgi + +import ( + "bytes" + "context" + "fmt" + "path/filepath" + "strings" + + sr "tildegit.org/tjp/sliderule" + "tildegit.org/tjp/sliderule/logging" + "tildegit.org/tjp/sliderule/spartan" +) + +// SpartanCGIDirectory runs any executable files relative to a root directory on the file system. +// +// It will also find and run any executables _part way_ through the path, so for example +// a request for /foo/bar/baz can also run an executable found at /foo or /foo/bar. In +// such a case the PATH_INFO environment variable will include the remaining portion of +// the URI path. +func SpartanCGIDirectory(fsroot, urlroot, cmd string) sr.Handler { + fsroot = strings.TrimRight(fsroot, "/") + return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response { + if !strings.HasPrefix(request.Path, urlroot) { + return nil + } + + execpath, pathinfo, err := ResolveCGI(request.Path[len(urlroot):], fsroot) + if err != nil { + return spartan.ServerError(err) + } + if execpath == "" { + return nil + } + workdir := filepath.Dir(execpath) + + if cmd != "" { + execpath = cmd + } + + stderr := &bytes.Buffer{} + stdout, exitCode, err := RunCGI(ctx, request, execpath, pathinfo, workdir, stderr) + if err != nil { + return spartan.ServerError(err) + } + if exitCode != 0 { + ctx.Value("warnlog").(logging.Logger).Log( + "msg", "cgi exited with non-zero exit code", + "code", exitCode, + "stderr", stderr.String(), + ) + return spartan.ServerError(fmt.Errorf("CGI process exited with status %d", exitCode)) + } + + response, err := spartan.ParseResponse(stdout) + if err != nil { + return spartan.ServerError(err) + } + return response + }) +} diff --git a/contrib/fs/gemini.go b/contrib/fs/gemini.go index 1fb4e20..79dcc63 100644 --- a/contrib/fs/gemini.go +++ b/contrib/fs/gemini.go @@ -127,17 +127,17 @@ func GeminiDirectoryDefault(fsroot, urlroot string, filenames ...string) sr.Hand fsroot = strings.TrimRight(fsroot, "/") return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response { + if !strings.HasPrefix(request.Path, urlroot) { + return nil + } + if !strings.HasSuffix(request.Path, "/") { u := *request.URL u.Path += "/" return gemini.PermanentRedirect(u.String()) } - if !strings.HasPrefix(request.Path, urlroot) { - return nil - } requestpath := strings.Trim(strings.TrimPrefix(request.Path, urlroot), "/") - fpath := filepath.Join(fsroot, requestpath) if isPrivate(fpath) { return nil diff --git a/contrib/fs/spartan.go b/contrib/fs/spartan.go new file mode 100644 index 0000000..bee274a --- /dev/null +++ b/contrib/fs/spartan.go @@ -0,0 +1,145 @@ +package fs + +import ( + "context" + "os" + "path/filepath" + "strings" + "text/template" + + sr "tildegit.org/tjp/sliderule" + "tildegit.org/tjp/sliderule/spartan" +) + +// SpartanFileHandler builds a handler which serves up files from a root directory. +// +// It only serves responses for paths which correspond to regular files or symlinks to them. +func SpartanFileHandler(fsroot, urlroot string) sr.Handler { + fsroot = strings.TrimRight(fsroot, "/") + + return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response { + if !strings.HasPrefix(request.Path, urlroot) { + return nil + } + requestpath := strings.Trim(strings.TrimPrefix(request.Path, urlroot), "/") + + fpath := filepath.Join(fsroot, requestpath) + if isPrivate(fpath) { + return nil + } + if isf, err := isFile(fpath); err != nil { + return spartan.ServerError(err) + } else if !isf { + return nil + } + + file, err := os.Open(fpath) + if err != nil { + return spartan.ServerError(err) + } + return spartan.Success(mediaType(fpath), file) + }) +} + +// SpartanDirectoryDefault serves up default files for directory path requests. +// +// If any of the supported filenames are found, the contents of the file is returned as the +// spartan response. +// +// It returns nil for any paths which don't correspond to a directory. +// +// When it encounters a directory path which doesn't end in a trailing slash (/) it +// redirects to the URL with the slash appended. This is necessary for relative links +// in the directory's contents to function properly. +func SpartanDirectoryDefault(fsroot, urlroot string, filenames ...string) sr.Handler { + fsroot = strings.TrimRight(fsroot, "/") + + return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response { + if !strings.HasPrefix(request.Path, urlroot) { + return nil + } + + if !strings.HasSuffix(request.Path, "/") { + u := *request.URL + u.Path += "/" + return spartan.Redirect(u.String()) + } + + requestpath := strings.Trim(strings.TrimPrefix(request.Path, urlroot), "/") + fpath := filepath.Join(fsroot, requestpath) + if isPrivate(fpath) { + return nil + } + if isd, err := isDir(fpath); err != nil { + return spartan.ServerError(err) + } else if !isd { + return nil + } + + for _, fname := range filenames { + candidatepath := filepath.Join(fpath, fname) + if isf, err := isFile(candidatepath); err != nil { + return spartan.ServerError(err) + } else if !isf { + continue + } + + file, err := os.Open(candidatepath) + if err != nil { + return spartan.ServerError(err) + } + return spartan.Success(mediaType(candidatepath), file) + } + + return nil + }) +} + +// SpartanDirectoryListing produces a listing of the contents of any requested directories. +// +// It returns a nil response for any paths which don't correspond to a filesystem directory. +// +// When it encounters a directory path which doesn't end in a trailing slash (/) it +// redirects to a URL with the trailing slash appended. This is necessary for relative +// links not the directory's contents to function properly. +// +// The template may be nil, in which case DefaultSpartanDirectoryList is used instead. The +// template is then processed with RenderDirectoryListing. +func SpartanDirectoryListing(fsroot, urlroot string, template *template.Template) sr.Handler { + fsroot = strings.TrimRight(fsroot, "/") + + return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response { + if !strings.HasSuffix(request.Path, "/") { + u := *request.URL + u.Path += "/" + return spartan.Redirect(u.String()) + } + if !strings.HasPrefix(request.Path, urlroot) { + return nil + } + requestpath := strings.Trim(strings.TrimPrefix(request.Path, urlroot), "/") + + fpath := filepath.Join(fsroot, requestpath) + if isPrivate(fpath) { + return nil + } + if isd, err := isDir(fpath); err != nil { + return spartan.ServerError(err) + } else if !isd { + return nil + } + + if template == nil { + template = DefaultSpartanDirectoryList + } + body, err := RenderDirectoryListing(fpath, requestpath, template, request.Server) + if err != nil { + return spartan.ServerError(err) + } + + return spartan.Success("text/gemini", body) + }) +} + +// DefaultSpartanDirectoryList is a tmeplate which renders a reasonable gemtext dir listing. +var DefaultSpartanDirectoryList = DefaultGeminiDirectoryList -- cgit v1.2.3