Update Dockerfile

- Switch Dockerfile base image from golang:1.23-bookworm to debian:12-slim
- Update Dockerfile to use pre-built binary instead of building in container
- Fix Docker CMD to use new CLI flag format with --listen and --root-path
- Update Makefile to build binary to ./dist/ directory with CGO_ENABLED=0
- Make build-docker target depend on build target for efficiency
- Change clean target to remove ./dist directory instead of single binary

.gitignore

@@ -2,3 +2,5 @@
 **/*~
 /.idea
 /run.sh
+/dist
+/go.work*

Dockerfile

@@ -1,15 +1,16 @@
-FROM golang:1.23-bookworm
+FROM debian:12-slim
 
 RUN apt-get update && apt-get upgrade -y
 
 RUN useradd -u 1000 -m user
 
-COPY ./gemserve /app/gemserve
+COPY ./dist/gemserve /app/gemserve
 
 WORKDIR /app
 
 RUN chmod +x /app/gemserve && \
-    chown -R user:user /app
+    chown -R root:root /app && \
+    chmod -R 755 /app
 
 USER user
-CMD ["/app/gemserve","0.0.0.0:1965"]
+CMD ["/app/gemserve","--listen","0.0.0.0:1965","--root-path","/srv"]

Makefile

@@ -4,7 +4,7 @@ export PATH := $(PATH)
 all: fmt lintfix tidy test clean build
 
 clean:
-	rm -f ./gemserve
+	rm -rf ./dist
 
 debug:
 	@echo "PATH: $(PATH)"
@@ -19,7 +19,8 @@ test:
 	go test ./...
 
 tidy:
-	go mod tidy
+	go work sync
+	#go mod tidy
 
 # Format code
 fmt:
@@ -35,9 +36,10 @@ lintfix: fmt
 	golangci-lint run --fix
 
 build:
-	go build -o ./gemserve ./main.go
+	mkdir -p ./dist
+	CGO_ENABLED=0 go build -o ./dist/gemserve ./main.go
 
-build-docker:
+build-docker: build
 	docker build -t gemserve .
 
 show-updates:

README.md

@@ -18,17 +18,12 @@ make #run tests and build
 Run:
 
 ```shell
-LOG_LEVEL=info \
-PANIC_ON_UNEXPECTED_ERROR=true \
-RESPONSE_TIMEOUT=10 \ #seconds
-ROOT_PATH=./srv \
-DIR_INDEXING_ENABLED=false \
-./gemserve 0.0.0.0:1965
+./dist/gemserve
 ```
 
 You'll need TLS keys, you can use `certs/generate.sh`
 for quick generation.
 
 ## TODO
-- [ ] Make TLS keys path configurable via venv
+- [ ] Make TLS keys path configurable
 - [ ] Fix slowloris (proper response timeouts)

common/gemini_url.go

@@ -8,7 +8,7 @@ import (
 	"strconv"
 	"strings"
 
-	"gemserve/errors"
+	"git.antanst.com/antanst/xerrors"
 )
 
 type URL struct {
@@ -28,7 +28,7 @@ func (u *URL) Scan(value interface{}) error {
 	}
 	b, ok := value.(string)
 	if !ok {
-		return errors.NewFatalError(fmt.Errorf("database scan error: expected string, got %T", value))
+		return xerrors.NewError(fmt.Errorf("database scan error: expected string, got %T", value), 0, "Database scan error", true)
 	}
 	parsedURL, err := ParseURL(b, "", false)
 	if err != nil {
@@ -67,12 +67,10 @@ func ParseURL(input string, descr string, normalize bool) (*URL, error) {
 	} else {
 		u, err = url.Parse(input)
 		if err != nil {
-			return nil, errors.NewError(fmt.Errorf("error parsing URL: %w: %s", err, input))
+			return nil, xerrors.NewError(fmt.Errorf("error parsing URL: %w: %s", err, input), 0, "URL parse error", false)
 		}
 	}
-	if u.Scheme != "gemini" {
-		return nil, errors.NewError(fmt.Errorf("error parsing URL: not a gemini URL: %s", input))
-	}
+
 	protocol := u.Scheme
 	hostname := u.Hostname()
 	strPort := u.Port()
@@ -82,7 +80,7 @@ func ParseURL(input string, descr string, normalize bool) (*URL, error) {
 	}
 	port, err := strconv.Atoi(strPort)
 	if err != nil {
-		return nil, errors.NewError(fmt.Errorf("error parsing URL: %w: %s", err, input))
+		return nil, xerrors.NewError(fmt.Errorf("error parsing URL: %w: %s", err, input), 0, "URL parse error", false)
 	}
 	full := fmt.Sprintf("%s://%s:%d%s", protocol, hostname, port, urlPath)
 	// full field should also contain query params and url fragments
@@ -128,13 +126,13 @@ func NormalizeURL(rawURL string) (*url.URL, error) {
 	// Parse the URL
 	u, err := url.Parse(rawURL)
 	if err != nil {
-		return nil, errors.NewError(fmt.Errorf("error normalizing URL: %w: %s", err, rawURL))
+		return nil, xerrors.NewError(fmt.Errorf("error normalizing URL: %w: %s", err, rawURL), 0, "URL normalization error", false)
 	}
 	if u.Scheme == "" {
-		return nil, errors.NewError(fmt.Errorf("error normalizing URL: No scheme: %s", rawURL))
+		return nil, xerrors.NewError(fmt.Errorf("error normalizing URL: No scheme: %s", rawURL), 0, "Missing URL scheme", false)
 	}
 	if u.Host == "" {
-		return nil, errors.NewError(fmt.Errorf("error normalizing URL: No host: %s", rawURL))
+		return nil, xerrors.NewError(fmt.Errorf("error normalizing URL: No host: %s", rawURL), 0, "Missing URL host", false)
 	}
 
 	// Convert scheme to lowercase

config/config.go

@@ -1,126 +1,69 @@
 package config
 
 import (
+	"flag"
 	"fmt"
+	"log/slog"
 	"os"
-	"strconv"
-
-	"github.com/rs/zerolog"
+	"strings"
 )
 
-// Environment variable names.
-const (
-	EnvLogLevel               = "LOG_LEVEL"
-	EnvResponseTimeout        = "RESPONSE_TIMEOUT"
-	EnvPanicOnUnexpectedError = "PANIC_ON_UNEXPECTED_ERROR"
-	EnvRootPath               = "ROOT_PATH"
-	EnvDirIndexingEnabled     = "DIR_INDEXING_ENABLED"
-)
-
-// Config holds the application configuration loaded from environment variables.
+// Config holds the application configuration loaded from CLI flags.
 type Config struct {
-	LogLevel               zerolog.Level // Logging level (debug, info, warn, error)
+	LogLevel           slog.Level // Logging level (debug, info, warn, error)
 	ResponseTimeout    int        // Timeout for responses in seconds
-	PanicOnUnexpectedError bool          // Panic on unexpected errors when visiting a URL
 	RootPath           string     // Path to serve files from
 	DirIndexingEnabled bool       // Allow client to browse directories or not
+	Listen             string     // Address to listen on
 }
 
 var CONFIG Config //nolint:gochecknoglobals
 
-// parsePositiveInt parses and validates positive integer values.
-func parsePositiveInt(param, value string) (int, error) {
-	val, err := strconv.Atoi(value)
-	if err != nil {
-		return 0, ValidationError{
-			Param:  param,
-			Value:  value,
-			Reason: "must be a valid integer",
+// parseLogLevel parses a log level string into slog.Level
+func parseLogLevel(level string) (slog.Level, error) {
+	switch strings.ToLower(level) {
+	case "debug":
+		return slog.LevelDebug, nil
+	case "info":
+		return slog.LevelInfo, nil
+	case "warn", "warning":
+		return slog.LevelWarn, nil
+	case "error":
+		return slog.LevelError, nil
+	default:
+		return slog.LevelInfo, fmt.Errorf("invalid log level: %s", level)
 	}
 }
-	if val <= 0 {
-		return 0, ValidationError{
-			Param:  param,
-			Value:  value,
-			Reason: "must be positive",
-		}
-	}
-	return val, nil
-}
 
-func parseBool(param, value string) (bool, error) {
-	val, err := strconv.ParseBool(value)
-	if err != nil {
-		return false, ValidationError{
-			Param:  param,
-			Value:  value,
-			Reason: "cannot be converted to boolean",
-		}
-	}
-	return val, nil
-}
-
-// GetConfig loads and validates configuration from environment variables
+// GetConfig loads and validates configuration from CLI flags
 func GetConfig() *Config {
-	config := &Config{}
+	// Define CLI flags with defaults
+	logLevel := flag.String("log-level", "info", "Logging level (debug, info, warn, error)")
+	responseTimeout := flag.Int("response-timeout", 30, "Timeout for responses in seconds")
+	rootPath := flag.String("root-path", "", "Path to serve files from")
+	dirIndexing := flag.Bool("dir-indexing", false, "Allow client to browse directories")
+	listen := flag.String("listen", "localhost:1965", "Address to listen on")
 
-	// Map of environment variables to their parsing functions
-	parsers := map[string]func(string) error{
-		EnvLogLevel: func(v string) error {
-			level, err := zerolog.ParseLevel(v)
-			if err != nil {
-				return ValidationError{
-					Param:  EnvLogLevel,
-					Value:  v,
-					Reason: "must be one of: debug, info, warn, error",
-				}
-			}
-			config.LogLevel = level
-			return nil
-		},
-		EnvResponseTimeout: func(v string) error {
-			val, err := parsePositiveInt(EnvResponseTimeout, v)
-			if err != nil {
-				return err
-			}
-			config.ResponseTimeout = val
-			return nil
-		},
-		EnvPanicOnUnexpectedError: func(v string) error {
-			val, err := parseBool(EnvPanicOnUnexpectedError, v)
-			if err != nil {
-				return err
-			}
-			config.PanicOnUnexpectedError = val
-			return nil
-		},
-		EnvRootPath: func(v string) error {
-			config.RootPath = v
-			return nil
-		},
-		EnvDirIndexingEnabled: func(v string) error {
-			val, err := parseBool(EnvDirIndexingEnabled, v)
-			if err != nil {
-				return err
-			}
-			config.DirIndexingEnabled = val
-			return nil
-		},
-	}
+	flag.Parse()
 
-	// Process each environment variable
-	for envVar, parser := range parsers {
-		value, ok := os.LookupEnv(envVar)
-		if !ok {
-			_, _ = fmt.Fprintf(os.Stderr, "Missing required environment variable: %s\n", envVar)
+	// Parse and validate log level
+	level, err := parseLogLevel(*logLevel)
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Invalid log level '%s': must be one of: debug, info, warn, error\n", *logLevel)
 		os.Exit(1)
 	}
 
-		if err := parser(value); err != nil {
-			_, _ = fmt.Fprintf(os.Stderr, "Configuration error: %v\n", err)
+	// Validate response timeout
+	if *responseTimeout <= 0 {
+		_, _ = fmt.Fprintf(os.Stderr, "Invalid response timeout '%d': must be positive\n", *responseTimeout)
 		os.Exit(1)
 	}
-	}
 
-	return config
+	return &Config{
+		LogLevel:           level,
+		ResponseTimeout:    *responseTimeout,
+		RootPath:           *rootPath,
+		DirIndexingEnabled: *dirIndexing,
+		Listen:             *listen,
+	}
 }

config/errors.go

@@ -1,14 +0,0 @@
-package config
-
-import "fmt"
-
-// ValidationError represents a config validation error
-type ValidationError struct {
-	Param  string
-	Value  string
-	Reason string
-}
-
-func (e ValidationError) Error() string {
-	return fmt.Sprintf("invalid value '%s' for %s: %s", e.Value, e.Param, e.Reason)
-}

errors/errors.go

@@ -1,114 +0,0 @@
-package errors
-
-import (
-	"errors"
-	"fmt"
-	"runtime"
-	"strings"
-)
-
-type fatal interface {
-	Fatal() bool
-}
-
-func IsFatal(err error) bool {
-	te, ok := errors.Unwrap(err).(fatal)
-	return ok && te.Fatal()
-}
-
-func As(err error, target any) bool {
-	return errors.As(err, target)
-}
-
-func Is(err, target error) bool {
-	return errors.Is(err, target)
-}
-
-func Unwrap(err error) error {
-	return errors.Unwrap(err)
-}
-
-type Error struct {
-	Err   error
-	Stack string
-	fatal bool
-}
-
-func (e *Error) Error() string {
-	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("%v\n", e.Err))
-	return sb.String()
-}
-
-func (e *Error) ErrorWithStack() string {
-	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("%v\n", e.Err))
-	sb.WriteString(fmt.Sprintf("Stack Trace:\n%s", e.Stack))
-	return sb.String()
-}
-
-func (e *Error) Fatal() bool {
-	return e.fatal
-}
-
-func (e *Error) Unwrap() error {
-	return e.Err
-}
-
-func NewError(err error) error {
-	if err == nil {
-		return nil
-	}
-
-	// Check if it's already of our own
-	// Error type, so we don't add stack twice.
-	var asError *Error
-	if errors.As(err, &asError) {
-		return err
-	}
-
-	// Get the stack trace
-	var stack strings.Builder
-	buf := make([]uintptr, 50)
-	n := runtime.Callers(2, buf)
-	frames := runtime.CallersFrames(buf[:n])
-
-	// Format the stack trace
-	for {
-		frame, more := frames.Next()
-		// Skip runtime and standard library frames
-		if !strings.Contains(frame.File, "runtime/") {
-			stack.WriteString(fmt.Sprintf("\t%s:%d - %s\n", frame.File, frame.Line, frame.Function))
-		}
-		if !more {
-			break
-		}
-	}
-
-	return &Error{
-		Err:   err,
-		Stack: stack.String(),
-	}
-}
-
-func NewFatalError(err error) error {
-	if err == nil {
-		return nil
-	}
-
-	// Check if it's already of our own
-	// Error type.
-	var asError *Error
-	if errors.As(err, &asError) {
-		return err
-	}
-	err2 := NewError(err)
-	err2.(*Error).fatal = true
-	return err2
-}
-
-var ConnectionError error = fmt.Errorf("connection error")
-
-func NewConnectionError(err error) error {
-	return fmt.Errorf("%w: %w", ConnectionError, err)
-}

errors/errors_test.go

@@ -1,71 +0,0 @@
-package errors
-
-import (
-	"errors"
-	"fmt"
-	"testing"
-)
-
-type CustomError struct {
-	Err error
-}
-
-func (e *CustomError) Error() string { return e.Err.Error() }
-
-func IsCustomError(err error) bool {
-	var asError *CustomError
-	return errors.As(err, &asError)
-}
-
-func TestWrapping(t *testing.T) {
-	t.Parallel()
-	originalErr := errors.New("original error")
-	err1 := NewError(originalErr)
-	if !errors.Is(err1, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-	if !Is(err1, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-	unwrappedErr := errors.Unwrap(err1)
-	if !errors.Is(unwrappedErr, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-	if !Is(unwrappedErr, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-	unwrappedErr = Unwrap(err1)
-	if !errors.Is(unwrappedErr, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-	if !Is(unwrappedErr, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-	wrappedErr := fmt.Errorf("wrapped: %w", originalErr)
-	if !errors.Is(wrappedErr, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-	if !Is(wrappedErr, originalErr) {
-		t.Errorf("original error is not wrapped")
-	}
-}
-
-func TestNewError(t *testing.T) {
-	t.Parallel()
-	originalErr := &CustomError{errors.New("err1")}
-	if !IsCustomError(originalErr) {
-		t.Errorf("TestNewError fail #1")
-	}
-	err1 := NewError(originalErr)
-	if !IsCustomError(err1) {
-		t.Errorf("TestNewError fail #2")
-	}
-	wrappedErr1 := fmt.Errorf("wrapped %w", err1)
-	if !IsCustomError(wrappedErr1) {
-		t.Errorf("TestNewError fail #3")
-	}
-	unwrappedErr1 := Unwrap(wrappedErr1)
-	if !IsCustomError(unwrappedErr1) {
-		t.Errorf("TestNewError fail #4")
-	}
-}

go.mod

@@ -1,16 +1,12 @@
 module gemserve
 
-go 1.23.4
+go 1.24.3
 
 require (
+	git.antanst.com/antanst/logging v0.0.1
+	git.antanst.com/antanst/xerrors v0.0.1
 	github.com/gabriel-vasile/mimetype v1.4.8
 	github.com/matoous/go-nanoid/v2 v2.1.0
-	github.com/rs/zerolog v1.33.0
 )
 
-require (
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
-	golang.org/x/net v0.33.0 // indirect
-	golang.org/x/sys v0.29.0 // indirect
-)
+require golang.org/x/net v0.33.0 // indirect

go.sum

@@ -1,30 +1,14 @@
-github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
 github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/matoous/go-nanoid/v2 v2.1.0 h1:P64+dmq21hhWdtvZfEAofnvJULaRR1Yib0+PnU669bE=
 github.com/matoous/go-nanoid/v2 v2.1.0/go.mod h1:KlbGNQ+FhrUNIHUxZdL63t7tl4LaPkZNpUULS8H4uVM=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
-github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
 golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

logging/logging.go

@@ -1,23 +0,0 @@
-package logging
-
-import (
-	"fmt"
-
-	zlog "github.com/rs/zerolog/log"
-)
-
-func LogDebug(format string, args ...interface{}) {
-	zlog.Debug().Msg(fmt.Sprintf(format, args...))
-}
-
-func LogInfo(format string, args ...interface{}) {
-	zlog.Info().Msg(fmt.Sprintf(format, args...))
-}
-
-func LogWarn(format string, args ...interface{}) {
-	zlog.Warn().Msg(fmt.Sprintf(format, args...))
-}
-
-func LogError(format string, args ...interface{}) {
-	zlog.Error().Err(fmt.Errorf(format, args...)).Msg("")
-}

main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"crypto/tls"
+	"errors"
 	"fmt"
 	"io"
 	"net"
@@ -13,46 +14,40 @@ import (
 	"time"
 
 	"gemserve/config"
-	"gemserve/errors"
-	"gemserve/logging"
 	"gemserve/server"
 	"gemserve/uid"
-	"github.com/rs/zerolog"
-	zlog "github.com/rs/zerolog/log"
+	logging "git.antanst.com/antanst/logging"
+	"git.antanst.com/antanst/xerrors"
 )
 
+var fatalErrors chan error
+
 func main() {
 	config.CONFIG = *config.GetConfig()
-	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
-	zerolog.SetGlobalLevel(config.CONFIG.LogLevel)
-	zlog.Logger = zlog.Output(zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: "[2006-01-02 15:04:05]"})
+
+	logging.InitSlogger(config.CONFIG.LogLevel)
+
 	err := runApp()
 	if err != nil {
-		fmt.Printf("%v\n", err)
-		logging.LogError("%v", err)
-		os.Exit(1)
+		panic(fmt.Sprintf("Fatal Error: %v", err))
 	}
+	os.Exit(0)
 }
 
 func runApp() error {
 	logging.LogInfo("Starting up. Press Ctrl+C to exit")
 
-	var listenHost string
-	if len(os.Args) != 2 {
-		listenHost = "0.0.0.0:1965"
-	} else {
-		listenHost = os.Args[1]
-	}
+	listenHost := config.CONFIG.Listen
 
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 
-	serverErrors := make(chan error)
+	fatalErrors = make(chan error)
 
 	go func() {
 		err := startServer(listenHost)
 		if err != nil {
-			serverErrors <- errors.NewFatalError(err)
+			fatalErrors <- xerrors.NewError(err, 0, "Server startup failed", true)
 		}
 	}()
 
@@ -61,16 +56,16 @@ func runApp() error {
 		case <-signals:
 			logging.LogWarn("Received SIGINT or SIGTERM signal, exiting")
 			return nil
-		case serverError := <-serverErrors:
-			return errors.NewFatalError(serverError)
+		case fatalError := <-fatalErrors:
+			return xerrors.NewError(fatalError, 0, "Server error", true)
 		}
 	}
 }
 
 func startServer(listenHost string) (err error) {
-	cert, err := tls.LoadX509KeyPair("/certs/cert", "/certs/key")
+	cert, err := tls.LoadX509KeyPair("certs/server.crt", "certs/server.key")
 	if err != nil {
-		return errors.NewFatalError(fmt.Errorf("failed to load certificate: %w", err))
+		return xerrors.NewError(fmt.Errorf("failed to load certificate: %w", err), 0, "Certificate loading failed", true)
 	}
 
 	tlsConfig := &tls.Config{
@@ -80,7 +75,7 @@ func startServer(listenHost string) (err error) {
 
 	listener, err := tls.Listen("tcp", listenHost, tlsConfig)
 	if err != nil {
-		return errors.NewFatalError(fmt.Errorf("failed to create listener: %w", err))
+		return xerrors.NewError(fmt.Errorf("failed to create listener: %w", err), 0, "Listener creation failed", true)
 	}
 	defer func(listener net.Listener) {
 		// If we've got an error closing the
@@ -88,7 +83,7 @@ func startServer(listenHost string) (err error) {
 		// the original error (if not nil)
 		errClose := listener.Close()
 		if errClose != nil && err == nil {
-			err = errors.NewFatalError(err)
+			err = xerrors.NewError(err, 0, "Listener close failed", true)
 		}
 	}(listener)
 
@@ -102,16 +97,16 @@ func startServer(listenHost string) (err error) {
 		}
 
 		go func() {
-			err := handleConnection(conn.(*tls.Conn))
+			remoteAddr := conn.RemoteAddr().String()
+			connId := uid.UID()
+			err := handleConnection(conn.(*tls.Conn), connId, remoteAddr)
 			if err != nil {
-				var asErr *errors.Error
-				if errors.As(err, &asErr) {
-					logging.LogError("Unexpected error: %v", err.(*errors.Error).ErrorWithStack())
+				var asErr *xerrors.XError
+				if errors.As(err, &asErr) && asErr.IsFatal {
+					fatalErrors <- asErr
+					return
 				} else {
-					logging.LogError("Unexpected error: %v", err)
-				}
-				if config.CONFIG.PanicOnUnexpectedError {
-					panic("Encountered unexpected error")
+					logging.LogWarn("%s %s Connection failed: %d %s (%v)", connId, remoteAddr, asErr.Code, asErr.UserMsg, err)
 				}
 			}
 		}()
@@ -121,56 +116,68 @@ func startServer(listenHost string) (err error) {
 func closeConnection(conn *tls.Conn) error {
 	err := conn.CloseWrite()
 	if err != nil {
-		return errors.NewConnectionError(fmt.Errorf("failed to close TLS connection: %w", err))
+		return xerrors.NewError(fmt.Errorf("failed to close TLS connection: %w", err), 50, "Connection close failed", false)
 	}
 	err = conn.Close()
 	if err != nil {
-		return errors.NewConnectionError(fmt.Errorf("failed to close connection: %w", err))
+		return xerrors.NewError(fmt.Errorf("failed to close connection: %w", err), 50, "Connection close failed", false)
 	}
 	return nil
 }
 
-func handleConnection(conn *tls.Conn) (err error) {
-	remoteAddr := conn.RemoteAddr().String()
-	connId := uid.UID()
+func handleConnection(conn *tls.Conn, connId string, remoteAddr string) (err error) {
 	start := time.Now()
 	var outputBytes []byte
 
 	defer func(conn *tls.Conn) {
-		// Three possible cases here:
-		// - We don't have an error
-		// - We have a ConnectionError, which we don't propagate up
-		// - We have an unexpected error.
 		end := time.Now()
 		tookMs := end.Sub(start).Milliseconds()
 		var responseHeader string
-		if err != nil {
-			_, _ = conn.Write([]byte("50 server error"))
-			responseHeader = "50 server error"
-			// We don't propagate connection errors up.
-			if errors.Is(err, errors.ConnectionError) {
-				logging.LogInfo("%s %s %v", connId, remoteAddr, err)
-				err = nil
-			}
-		} else {
+
+		// On non-errors, just log response and close connection.
+		if err == nil {
+			// Log non-erroneous responses
 			if i := bytes.Index(outputBytes, []byte{'\r'}); i >= 0 {
 				responseHeader = string(outputBytes[:i])
 			}
-		}
 			logging.LogInfo("%s %s response %s (%dms)", connId, remoteAddr, responseHeader, tookMs)
 			_ = closeConnection(conn)
+			return
+		}
+
+		var code int
+		var responseMsg string
+		var xErr *xerrors.XError
+		if errors.As(err, &xErr) {
+			// On fatal errors, immediatelly return the error.
+			if xErr.IsFatal {
+				_ = closeConnection(conn)
+				return
+			}
+			code = xErr.Code
+			responseMsg = xErr.UserMsg
+		} else {
+			code = 50
+			responseMsg = "server error"
+		}
+		responseHeader = fmt.Sprintf("%d %s", code, responseMsg)
+		_, _ = conn.Write([]byte(responseHeader))
+		_ = closeConnection(conn)
 	}(conn)
 
 	// Gemini is supposed to have a 1kb limit
 	// on input requests.
-	buffer := make([]byte, 1024)
+	buffer := make([]byte, 1025)
 
 	n, err := conn.Read(buffer)
 	if err != nil && err != io.EOF {
-		return errors.NewConnectionError(fmt.Errorf("failed to read connection data: %w", err))
+		return xerrors.NewError(fmt.Errorf("failed to read connection data: %w", err), 59, "Connection read failed", false)
 	}
 	if n == 0 {
-		return errors.NewConnectionError(fmt.Errorf("client did not send data"))
+		return xerrors.NewError(fmt.Errorf("client did not send data"), 59, "No data received", false)
+	}
+	if n > 1024 {
+		return xerrors.NewError(fmt.Errorf("client request size %d > 1024 bytes", n), 59, "Request too large", false)
 	}
 
 	dataBytes := buffer[:n]

server/server.go

@@ -2,16 +2,19 @@ package server
 
 import (
 	"crypto/tls"
+	"errors"
 	"fmt"
+	"net"
 	"os"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"
 
 	"gemserve/common"
 	"gemserve/config"
-	"gemserve/errors"
-	"gemserve/logging"
+	logging "git.antanst.com/antanst/logging"
+	"git.antanst.com/antanst/xerrors"
 	"github.com/gabriel-vasile/mimetype"
 )
 
@@ -20,18 +23,43 @@ type ServerConfig interface {
 	RootPath() string
 }
 
+func checkRequestURL(url *common.URL) error {
+	if url.Protocol != "gemini" {
+		return xerrors.NewError(fmt.Errorf("invalid URL"), 53, "URL Protocol not Gemini, proxying refused", false)
+	}
+
+	_, portStr, err := net.SplitHostPort(config.CONFIG.Listen)
+	if err != nil {
+		return xerrors.NewError(fmt.Errorf("failed to parse listen address: %w", err), 50, "Server configuration error", false)
+	}
+	listenPort, err := strconv.Atoi(portStr)
+	if err != nil {
+		return xerrors.NewError(fmt.Errorf("failed to parse listen port: %w", err), 50, "Server configuration error", false)
+	}
+	if url.Port != listenPort {
+		return xerrors.NewError(fmt.Errorf("failed to parse URL: %w", err), 53, "invalid URL port, proxying refused", false)
+	}
+	return nil
+}
+
 func GenerateResponse(conn *tls.Conn, connId string, input string) ([]byte, error) {
 	trimmedInput := strings.TrimSpace(input)
 	// url will have a cleaned and normalized path after this
 	url, err := common.ParseURL(trimmedInput, "", true)
 	if err != nil {
-		return nil, errors.NewConnectionError(fmt.Errorf("failed to parse URL: %w", err))
+		return nil, xerrors.NewError(fmt.Errorf("failed to parse URL: %w", err), 59, "Invalid URL", false)
 	}
 	logging.LogDebug("%s %s normalized URL path: %s", connId, conn.RemoteAddr(), url.Path)
+
+	err = checkRequestURL(url)
+	if err != nil {
+		return nil, err
+	}
+
 	serverRootPath := config.CONFIG.RootPath
 	localPath, err := calculateLocalPath(url.Path, serverRootPath)
 	if err != nil {
-		return nil, errors.NewConnectionError(err)
+		return nil, xerrors.NewError(err, 59, "Invalid path", false)
 	}
 	logging.LogDebug("%s %s request file path: %s", connId, conn.RemoteAddr(), localPath)
 
@@ -40,7 +68,7 @@ func GenerateResponse(conn *tls.Conn, connId string, input string) ([]byte, erro
 	if errors.Is(err, os.ErrNotExist) || errors.Is(err, os.ErrPermission) {
 		return []byte("51 not found\r\n"), nil
 	} else if err != nil {
-		return nil, errors.NewConnectionError(fmt.Errorf("%s %s failed to access path: %w", connId, conn.RemoteAddr(), err))
+		return nil, xerrors.NewError(fmt.Errorf("%s %s failed to access path: %w", connId, conn.RemoteAddr(), err), 0, "Path access failed", false)
 	}
 
 	// Handle directory.
@@ -55,7 +83,7 @@ func generateResponseFile(conn *tls.Conn, connId string, url *common.URL, localP
 	if errors.Is(err, os.ErrNotExist) || errors.Is(err, os.ErrPermission) {
 		return []byte("51 not found\r\n"), nil
 	} else if err != nil {
-		return nil, errors.NewConnectionError(fmt.Errorf("%s %s failed to read file: %w", connId, conn.RemoteAddr(), err))
+		return nil, xerrors.NewError(fmt.Errorf("%s %s failed to read file: %w", connId, conn.RemoteAddr(), err), 0, "File read failed", false)
 	}
 
 	var mimeType string
@@ -64,7 +92,7 @@ func generateResponseFile(conn *tls.Conn, connId string, url *common.URL, localP
 	} else {
 		mimeType = mimetype.Detect(data).String()
 	}
-	headerBytes := []byte(fmt.Sprintf("20 %s\r\n", mimeType))
+	headerBytes := []byte(fmt.Sprintf("20 %s; lang=en\r\n", mimeType))
 	response := append(headerBytes, data...)
 	return response, nil
 }
@@ -72,7 +100,7 @@ func generateResponseFile(conn *tls.Conn, connId string, url *common.URL, localP
 func generateResponseDir(conn *tls.Conn, connId string, url *common.URL, localPath string) (output []byte, err error) {
 	entries, err := os.ReadDir(localPath)
 	if err != nil {
-		return nil, errors.NewConnectionError(fmt.Errorf("%s %s failed to read directory: %w", connId, conn.RemoteAddr(), err))
+		return nil, xerrors.NewError(fmt.Errorf("%s %s failed to read directory: %w", connId, conn.RemoteAddr(), err), 0, "Directory read failed", false)
 	}
 
 	if config.CONFIG.DirIndexingEnabled {
@@ -87,7 +115,7 @@ func generateResponseDir(conn *tls.Conn, connId string, url *common.URL, localPa
 			}
 		}
 		data := []byte(strings.Join(contents, ""))
-		headerBytes := []byte("20 text/gemini;\r\n")
+		headerBytes := []byte("20 text/gemini; lang=en\r\n")
 		response := append(headerBytes, data...)
 		return response, nil
 	} else {
@@ -100,7 +128,7 @@ func generateResponseDir(conn *tls.Conn, connId string, url *common.URL, localPa
 func calculateLocalPath(input string, basePath string) (string, error) {
 	// Check for invalid characters early
 	if strings.ContainsAny(input, "\\") {
-		return "", errors.NewError(fmt.Errorf("invalid characters in path: %s", input))
+		return "", xerrors.NewError(fmt.Errorf("invalid characters in path: %s", input), 0, "Invalid path characters", false)
 	}
 
 	// If IsLocal(path) returns true, then Join(base, path)
@@ -116,7 +144,7 @@ func calculateLocalPath(input string, basePath string) (string, error) {
 
 	localPath, err := filepath.Localize(filePath)
 	if err != nil || !filepath.IsLocal(localPath) {
-		return "", errors.NewError(fmt.Errorf("could not construct local path from %s: %s", input, err))
+		return "", xerrors.NewError(fmt.Errorf("could not construct local path from %s: %s", input, err), 0, "Invalid local path", false)
 	}
 
 	filePath = path.Join(basePath, localPath)