molly-brown/handler.go

236 lines
5.5 KiB
Go
Raw Normal View History

2019-11-06 15:08:44 +00:00
package main
import (
"bufio"
"context"
2019-11-06 15:08:44 +00:00
"fmt"
"io"
2019-11-06 20:23:51 +00:00
"io/ioutil"
"log"
"mime"
2019-11-06 15:08:44 +00:00
"net"
"net/url"
2019-11-06 20:23:51 +00:00
"os"
"os/exec"
2019-11-06 20:23:51 +00:00
"path/filepath"
"regexp"
"strconv"
2019-11-06 20:23:51 +00:00
"strings"
2019-11-06 16:38:41 +00:00
"time"
2019-11-06 15:08:44 +00:00
)
2019-11-06 16:38:41 +00:00
func handleGeminiRequest(conn net.Conn, config Config, logEntries chan LogEntry) {
2019-11-06 15:08:44 +00:00
defer conn.Close()
2019-11-06 16:38:41 +00:00
var log LogEntry
log.Time = time.Now()
log.RemoteAddr = conn.RemoteAddr()
log.RequestURL = "-"
log.Status = 0
2019-11-06 16:50:44 +00:00
defer func() { logEntries <- log }()
2019-11-06 16:38:41 +00:00
2019-11-06 15:08:44 +00:00
// Read request
reader := bufio.NewReaderSize(conn, 1024)
request, overflow, err := reader.ReadLine()
if overflow {
conn.Write([]byte("59 Request too long!r\n"))
2019-11-06 16:38:41 +00:00
log.Status = 59
2019-11-06 15:08:44 +00:00
return
} else if err != nil {
conn.Write([]byte("40 Unknown error reading request!r\n"))
2019-11-06 16:38:41 +00:00
log.Status = 40
2019-11-06 15:08:44 +00:00
return
}
// Parse request as URL
URL, err := url.Parse(string(request))
if err != nil {
conn.Write([]byte("59 Error parsing URL!r\n"))
2019-11-06 16:38:41 +00:00
log.Status = 59
2019-11-06 15:08:44 +00:00
return
}
2019-11-06 16:38:41 +00:00
log.RequestURL = URL.String()
// Set implicit scheme
if URL.Scheme == "" {
URL.Scheme = "gemini"
}
// Reject non-gemini schemes
if URL.Scheme != "gemini" {
conn.Write([]byte("53 No proxying to non-Gemini content!\r\n"))
log.Status = 53
return
}
// Reject requests for content from other servers
requestHostname := strings.Split(URL.Host, ":")[0] // Shave off port
if requestHostname != config.Hostname {
conn.Write([]byte("53 No proxying to other hosts!\r\n"))
log.Status = 53
return
}
2019-11-06 20:23:51 +00:00
// Fail if there are dots in the path
if strings.Contains(URL.Path, "..") {
conn.Write([]byte("50 Your directory traversal technique has been defeated!\r\n"))
log.Status = 50
return
}
}
// Resolve URI path to actual filesystem path
path, info, err := resolvePath(URL.Path, config)
// Fail if file does not exist or perms aren't right
2019-11-06 20:23:51 +00:00
if os.IsNotExist(err) || os.IsPermission(err) {
conn.Write([]byte("51 Not found!\r\n"))
log.Status = 51
return
} else if err != nil {
conn.Write([]byte("40 Temporaray failure!\r\n"))
log.Status = 40
return
} else if uint64(info.Mode().Perm())&0444 != 0444 {
conn.Write([]byte("51 Not found!\r\n"))
log.Status = 51
return
2019-11-06 20:23:51 +00:00
}
// Handle directories
2019-11-06 20:23:51 +00:00
if info.IsDir() {
// Redirect to add trailing slash if missing
// (otherwise relative links don't work properly)
if !strings.HasSuffix(URL.Path, "/") {
conn.Write([]byte(fmt.Sprintf("31 %s\r\n", URL.String()+"/")))
log.Status = 31
return
}
// Serve a generated listing
2019-11-06 20:23:51 +00:00
conn.Write([]byte("20 text/gemini\r\n"))
log.Status = 20
conn.Write([]byte(generateDirectoryListing(path)))
return
}
// If this file is executable, get dynamic content
inCGIPath, err := regexp.Match(config.CGIPath, []byte(path))
if inCGIPath && info.Mode().Perm() & 0111 == 0111 {
handleCGI(path, URL, log, conn)
return
}
// Otherwise, serve the file contents
serveFile(path, log, conn)
return
}
func resolvePath(path string, config Config) (string, os.FileInfo, error) {
// Handle tildes
if strings.HasPrefix(path, "/~") {
bits := strings.Split(path, "/")
username := bits[1][1:]
new_prefix := filepath.Join(config.DocBase, config.HomeDocBase, username)
path = strings.Replace(path, bits[1], new_prefix, 1)
2019-11-06 20:23:51 +00:00
} else {
path = filepath.Join(config.DocBase, path)
}
// Make sure this file exists and is readable
info, err := os.Stat(path)
if err != nil {
return "", nil, err
}
// Check for index.gmi if path is a directory
if info.IsDir() {
index_path := filepath.Join(path, "index.gmi")
index_info, err := os.Stat(index_path)
if err == nil {
path = index_path
info = index_info
} else if os.IsPermission(err) {
return "", nil, err
}
2019-11-06 20:23:51 +00:00
}
return path, info, nil
2019-11-06 15:08:44 +00:00
}
2019-11-06 20:23:51 +00:00
func generateDirectoryListing(path string) string {
var listing string
files, err := ioutil.ReadDir(path)
if err != nil {
log.Fatal(err)
}
listing = "# Directory listing\n\n"
for _, file := range files {
2019-11-22 19:35:51 +00:00
// Skip dotfiles
if strings.HasPrefix(file.Name(), ".") {
continue
}
2019-11-21 21:03:39 +00:00
// Only list world readable files
if uint64(file.Mode().Perm())&0444 != 0444 {
continue
}
listing += fmt.Sprintf("=> %s %s\n", url.PathEscape(file.Name()), file.Name())
2019-11-06 20:23:51 +00:00
}
return listing
}
func serveFile(path string, log LogEntry, conn net.Conn) {
// Get MIME type of files
ext := filepath.Ext(path)
var mimeType string
if ext == ".gmi" {
mimeType = "text/gemini"
} else {
mimeType = mime.TypeByExtension(ext)
}
contents, err := ioutil.ReadFile(path)
if err != nil {
conn.Write([]byte("50 Error!\r\n"))
log.Status = 50
}
conn.Write([]byte(fmt.Sprintf("20 %s\r\n", mimeType)))
log.Status = 20
conn.Write(contents)
}
func handleCGI(path string, URL *url.URL, log LogEntry, conn net.Conn) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, path)
stdin, err := cmd.StdinPipe()
if err != nil {
conn.Write([]byte("42 CGI error!\r\n"))
log.Status = 42
return
}
defer stdin.Close()
io.WriteString(stdin, URL.String())
io.WriteString(stdin, "\r\n")
stdin.Close()
response, err := cmd.Output()
if ctx.Err() == context.DeadlineExceeded {
conn.Write([]byte("42 CGI process timed out!\r\n"))
log.Status = 42
return
}
if err != nil {
conn.Write([]byte("42 CGI error!\r\n"))
log.Status = 42
return
}
// Extract response header
header, _, err := bufio.NewReader(strings.NewReader(string(response))).ReadLine()
status, err2 := strconv.Atoi(strings.Fields(string(header))[0])
if err != nil || err2 != nil {
conn.Write([]byte("42 CGI error!\r\n"))
log.Status = 42
return
}
log.Status = status
// Write response
conn.Write(response)
}