fs: Prevent invalid directory links

A file with a name like "gemini:example" would previously result in the
following invalid link:

    => gemini:example gemini:example

Fix by prepending a "./" before each filename, so that the resulting
link looks like:

    => ./gemini:example gemini:example

README.md

@@ -6,7 +6,7 @@ Package gemini implements the [Gemini protocol](https://gemini.circumlunar.space
 in Go. It provides an API similar to that of net/http to facilitate the
 development of Gemini clients and servers.
 
-Compatible with version v0.14.3 of the Gemini specification.
+Compatible with version v0.16.0 of the Gemini specification.
 
 ## Usage
 

doc.go

@@ -30,7 +30,7 @@ Servers should be configured with certificates:
 	server.GetCertificate = certificates.Get
 
 Mux is a Gemini request multiplexer.
-Mux can handle requests for multiple hosts and schemes.
+Mux can handle requests for multiple hosts and paths.
 
 	mux := &gemini.Mux{}
 	mux.HandleFunc("example.com", func(ctx context.Context, w gemini.ResponseWriter, r *gemini.Request) {
@@ -39,8 +39,8 @@ Mux can handle requests for multiple hosts and schemes.
 	mux.HandleFunc("example.org/about.gmi", func(ctx context.Context, w gemini.ResponseWriter, r *gemini.Request) {
 		fmt.Fprint(w, "About example.org")
 	})
-	mux.HandleFunc("http://example.net", func(ctx context.Context, w gemini.ResponseWriter, r *gemini.Request) {
+	mux.HandleFunc("/images/", func(ctx context.Context, w gemini.ResponseWriter, r *gemini.Request) {
-		fmt.Fprint(w, "Proxied content from http://example.net")
+		w.WriteHeader(gemini.StatusGone, "Gone forever")
 	})
 	server.Handler = mux
 

fs.go

@@ -29,88 +29,22 @@ type fileServer struct {
 	fs.FS
 }
 
-func (fs fileServer) ServeGemini(ctx context.Context, w ResponseWriter, r *Request) {
+func (fsys fileServer) ServeGemini(ctx context.Context, w ResponseWriter, r *Request) {
-	serveFile(w, r, fs, path.Clean(r.URL.Path), true)
-}
-
-// ServeContent replies to the request using the content in the
-// provided Reader. The main benefit of ServeContent over io.Copy
-// is that it sets the MIME type of the response.
-//
-// ServeContent tries to deduce the type from name's file extension.
-// The name is otherwise unused; it is never sent in the response.
-func ServeContent(w ResponseWriter, r *Request, name string, content io.Reader) {
-	serveContent(w, name, content)
-}
-
-func serveContent(w ResponseWriter, name string, content io.Reader) {
-	// Detect mimetype from file extension
-	ext := path.Ext(name)
-	mimetype := mime.TypeByExtension(ext)
-	w.SetMediaType(mimetype)
-	io.Copy(w, content)
-}
-
-// ServeFile responds to the request with the contents of the named file
-// or directory.
-//
-// If the provided file or directory name is a relative path, it is interpreted
-// relative to the current directory and may ascend to parent directories. If
-// the provided name is constructed from user input, it should be sanitized
-// before calling ServeFile.
-//
-// As a precaution, ServeFile will reject requests where r.URL.Path contains a
-// ".." path element; this protects against callers who might unsafely use
-// path.Join on r.URL.Path without sanitizing it and then use that
-// path.Join result as the name argument.
-//
-// As another special case, ServeFile redirects any request where r.URL.Path
-// ends in "/index.gmi" to the same path, without the final "index.gmi". To
-// avoid such redirects either modify the path or use ServeContent.
-//
-// Outside of those two special cases, ServeFile does not use r.URL.Path for
-// selecting the file or directory to serve; only the file or directory
-// provided in the name argument is used.
-func ServeFile(w ResponseWriter, r *Request, fsys fs.FS, name string) {
-	if containsDotDot(r.URL.Path) {
-		// Too many programs use r.URL.Path to construct the argument to
-		// serveFile. Reject the request under the assumption that happened
-		// here and ".." may not be wanted.
-		// Note that name might not contain "..", for example if code (still
-		// incorrectly) used path.Join(myDir, r.URL.Path).
-		w.WriteHeader(StatusBadRequest, "invalid URL path")
-		return
-	}
-	serveFile(w, r, fsys, name, false)
-}
-
-func containsDotDot(v string) bool {
-	if !strings.Contains(v, "..") {
-		return false
-	}
-	for _, ent := range strings.FieldsFunc(v, isSlashRune) {
-		if ent == ".." {
-			return true
-		}
-	}
-	return false
-}
-
-func isSlashRune(r rune) bool { return r == '/' || r == '\\' }
-
-func serveFile(w ResponseWriter, r *Request, fsys fs.FS, name string, redirect bool) {
 	const indexPage = "/index.gmi"
 
+	url := path.Clean(r.URL.Path)
+
 	// Redirect .../index.gmi to .../
-	if strings.HasSuffix(r.URL.Path, indexPage) {
+	if strings.HasSuffix(url, indexPage) {
-		w.WriteHeader(StatusPermanentRedirect, "./")
+		w.WriteHeader(StatusPermanentRedirect, strings.TrimSuffix(url, "index.gmi"))
 		return
 	}
 
+	name := url
 	if name == "/" {
 		name = "."
 	} else {
-		name = strings.Trim(name, "/")
+		name = strings.TrimPrefix(name, "/")
 	}
 
 	f, err := fsys.Open(name)
@@ -127,51 +61,89 @@ func serveFile(w ResponseWriter, r *Request, fsys fs.FS, name string, redirect b
 	}
 
 	// Redirect to canonical path
-	if redirect {
+	if len(r.URL.Path) != 0 {
-		url := r.URL.Path
 		if stat.IsDir() {
-			// Add trailing slash
+			target := url
-			if url[len(url)-1] != '/' {
+			if target != "/" {
-				w.WriteHeader(StatusPermanentRedirect, path.Base(url)+"/")
+				target += "/"
+			}
+			if len(r.URL.Path) != len(target) || r.URL.Path != target {
+				w.WriteHeader(StatusPermanentRedirect, target)
 				return
 			}
-		} else {
+		} else if r.URL.Path[len(r.URL.Path)-1] == '/' {
 			// Remove trailing slash
-			if url[len(url)-1] == '/' {
+			w.WriteHeader(StatusPermanentRedirect, url)
-				w.WriteHeader(StatusPermanentRedirect, "../"+path.Base(url))
+			return
-				return
-			}
 		}
 	}
 
 	if stat.IsDir() {
-		// Redirect if the directory name doesn't end in a slash
-		url := r.URL.Path
-		if url[len(url)-1] != '/' {
-			w.WriteHeader(StatusRedirect, path.Base(url)+"/")
-			return
-		}
-
 		// Use contents of index.gmi if present
 		name = path.Join(name, indexPage)
 		index, err := fsys.Open(name)
 		if err == nil {
 			defer index.Close()
-			istat, err := index.Stat()
+			f = index
-			if err == nil {
+		} else {
-				f = index
+			// Failed to find index file
-				stat = istat
+			dirList(w, f)
-			}
+			return
 		}
 	}
 
-	if stat.IsDir() {
+	// Detect mimetype from file extension
-		// Failed to find index file
+	ext := path.Ext(name)
-		dirList(w, f)
+	mimetype := mime.TypeByExtension(ext)
+	w.SetMediaType(mimetype)
+	io.Copy(w, f)
+}
+
+// ServeFile responds to the request with the contents of the named file
+// or directory. If the provided name is constructed from user input, it
+// should be sanitized before calling ServeFile.
+func ServeFile(w ResponseWriter, fsys fs.FS, name string) {
+	const indexPage = "/index.gmi"
+
+	// Ensure name is relative
+	if name == "/" {
+		name = "."
+	} else {
+		name = strings.TrimLeft(name, "/")
+	}
+
+	f, err := fsys.Open(name)
+	if err != nil {
+		w.WriteHeader(toGeminiError(err))
+		return
+	}
+	defer f.Close()
+
+	stat, err := f.Stat()
+	if err != nil {
+		w.WriteHeader(toGeminiError(err))
 		return
 	}
 
-	serveContent(w, name, f)
+	if stat.IsDir() {
+		// Use contents of index file if present
+		name = path.Join(name, indexPage)
+		index, err := fsys.Open(name)
+		if err == nil {
+			defer index.Close()
+			f = index
+		} else {
+			// Failed to find index file
+			dirList(w, f)
+			return
+		}
+	}
+
+	// Detect mimetype from file extension
+	ext := path.Ext(name)
+	mimetype := mime.TypeByExtension(ext)
+	w.SetMediaType(mimetype)
+	io.Copy(w, f)
 }
 
 func dirList(w ResponseWriter, f fs.File) {
@@ -197,7 +169,7 @@ func dirList(w ResponseWriter, f fs.File) {
 		}
 		link := LineLink{
 			Name: name,
-			URL:  (&url.URL{Path: name}).EscapedPath(),
+			URL:  "./" + url.PathEscape(name),
 		}
 		fmt.Fprintln(w, link.String())
 	}

middleware.go

@@ -31,7 +31,12 @@ func (w *logResponseWriter) SetMediaType(mediatype string) {
 
 func (w *logResponseWriter) Write(b []byte) (int, error) {
 	if !w.wroteHeader {
-		w.WriteHeader(StatusSuccess, w.mediatype)
+		meta := w.mediatype
+		if meta == "" {
+			// Use default media type
+			meta = defaultMediaType
+		}
+		w.WriteHeader(StatusSuccess, meta)
 	}
 	n, err := w.rw.Write(b)
 	w.Wrote += n

mux.go

@@ -32,31 +32,15 @@ import (
 // the pattern "/" matches all paths not matched by other registered
 // patterns, not just the URL with Path == "/".
 //
-// Patterns may also contain schemes and hostnames.
+// Patterns may optionally begin with a host name, restricting matches to
-// Wildcard patterns can be used to match multiple hostnames (e.g. "*.example.com").
+// URLs on that host only. Host-specific patterns take precedence over
+// general patterns, so that a handler might register for the two patterns
+// "/search" and "search.example.com/" without also taking over requests
+// for "gemini://example.com/".
 //
-// The following are examples of valid patterns, along with the scheme,
+// Wildcard patterns can be used to match multiple hostnames. For example,
-// hostname, and path that they match.
+// the pattern "*.example.com" will match requests for "blog.example.com"
-//
+// and "gemini.example.com", but not "example.org".
-//     Pattern                      │ Scheme │ Hostname │ Path
-//     ─────────────────────────────┼────────┼──────────┼─────────────
-//     /file                        │ gemini │ *        │ /file
-//     /directory/                  │ gemini │ *        │ /directory/*
-//     hostname/file                │ gemini │ hostname │ /file
-//     hostname/directory/          │ gemini │ hostname │ /directory/*
-//     scheme://hostname/file       │ scheme │ hostname │ /file
-//     scheme://hostname/directory/ │ scheme │ hostname │ /directory/*
-//     //hostname/file              │ *      │ hostname │ /file
-//     //hostname/directory/        │ *      │ hostname │ /directory/*
-//     scheme:///file               │ scheme │ *        │ /file
-//     scheme:///directory/         │ scheme │ *        │ /directory/*
-//     ///file                      │ *      │ *        │ /file
-//     ///directory/                │ *      │ *        │ /directory/*
-//
-// A pattern without a hostname will match any hostname.
-// If a pattern begins with "//", it will match any scheme.
-// Otherwise, a pattern with no scheme is treated as though it has a
-// scheme of "gemini".
 //
 // If a subtree has been registered and a request is received naming the
 // subtree root without its trailing slash, Mux redirects that
@@ -71,19 +55,19 @@ import (
 // to an equivalent, cleaner URL.
 type Mux struct {
 	mu sync.RWMutex
-	m  map[muxKey]Handler
+	m  map[hostpath]Handler
 	es []muxEntry // slice of entries sorted from longest to shortest
 }
 
-type muxKey struct {
+type hostpath struct {
-	scheme string
+	host string
-	host   string
+	path string
-	path   string
 }
 
 type muxEntry struct {
 	handler Handler
-	key     muxKey
+	host    string
+	path    string
 }
 
 // cleanPath returns the canonical path for p, eliminating . and .. elements.
@@ -110,24 +94,17 @@ func cleanPath(p string) string {
 
 // Find a handler on a handler map given a path string.
 // Most-specific (longest) pattern wins.
-func (mux *Mux) match(key muxKey) Handler {
+func (mux *Mux) match(host, path string) Handler {
 	// Check for exact match first.
-	if r, ok := mux.m[key]; ok {
+	if h, ok := mux.m[hostpath{host, path}]; ok {
-		return r
+		return h
-	} else if r, ok := mux.m[muxKey{"", key.host, key.path}]; ok {
-		return r
-	} else if r, ok := mux.m[muxKey{key.scheme, "", key.path}]; ok {
-		return r
-	} else if r, ok := mux.m[muxKey{"", "", key.path}]; ok {
-		return r
 	}
 
 	// Check for longest valid match.  mux.es contains all patterns
 	// that end in / sorted from longest to shortest.
 	for _, e := range mux.es {
-		if (e.key.scheme == "" || key.scheme == e.key.scheme) &&
+		if len(e.host) == len(host) && e.host == host &&
-			(e.key.host == "" || key.host == e.key.host) &&
+			strings.HasPrefix(path, e.path) {
-			strings.HasPrefix(key.path, e.key.path) {
 			return e.handler
 		}
 	}
@@ -138,31 +115,32 @@ func (mux *Mux) match(key muxKey) Handler {
 // This occurs when a handler for path + "/" was already registered, but
 // not for path itself. If the path needs appending to, it creates a new
 // URL, setting the path to u.Path + "/" and returning true to indicate so.
-func (mux *Mux) redirectToPathSlash(key muxKey, u *url.URL) (*url.URL, bool) {
+func (mux *Mux) redirectToPathSlash(host, path string, u *url.URL) (*url.URL, bool) {
 	mux.mu.RLock()
-	shouldRedirect := mux.shouldRedirectRLocked(key)
+	shouldRedirect := mux.shouldRedirectRLocked(host, path)
 	mux.mu.RUnlock()
 	if !shouldRedirect {
 		return u, false
 	}
-	return u.ResolveReference(&url.URL{Path: key.path + "/"}), true
+	return u.ResolveReference(&url.URL{Path: path + "/"}), true
 }
 
 // shouldRedirectRLocked reports whether the given path and host should be redirected to
 // path+"/". This should happen if a handler is registered for path+"/" but
 // not path -- see comments at Mux.
-func (mux *Mux) shouldRedirectRLocked(key muxKey) bool {
+func (mux *Mux) shouldRedirectRLocked(host, path string) bool {
-	if _, exist := mux.m[key]; exist {
+	if _, exist := mux.m[hostpath{host, path}]; exist {
 		return false
 	}
 
-	n := len(key.path)
+	n := len(path)
 	if n == 0 {
 		return false
 	}
-	if _, exist := mux.m[muxKey{key.scheme, key.host, key.path + "/"}]; exist {
+	if _, exist := mux.m[hostpath{host, path + "/"}]; exist {
-		return key.path[n-1] != '/'
+		return path[n-1] != '/'
 	}
+
 	return false
 }
 
@@ -182,13 +160,17 @@ func getWildcard(hostname string) (string, bool) {
 // internally-generated handler that redirects to the canonical path. If the
 // host contains a port, it is ignored when matching handlers.
 func (mux *Mux) Handler(r *Request) Handler {
-	scheme := r.URL.Scheme
+	// Disallow non-Gemini schemes
+	if r.URL.Scheme != "gemini" {
+		return NotFoundHandler()
+	}
+
 	host := r.URL.Hostname()
 	path := cleanPath(r.URL.Path)
 
 	// If the given path is /tree and its handler is not registered,
 	// redirect for /tree/.
-	if u, ok := mux.redirectToPathSlash(muxKey{scheme, host, path}, r.URL); ok {
+	if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok {
 		return StatusHandler(StatusPermanentRedirect, u.String())
 	}
 
@@ -201,16 +183,30 @@ func (mux *Mux) Handler(r *Request) Handler {
 	mux.mu.RLock()
 	defer mux.mu.RUnlock()
 
-	h := mux.match(muxKey{scheme, host, path})
+	h := mux.match(host, path)
+
 	if h == nil {
 		// Try wildcard
 		if wildcard, ok := getWildcard(host); ok {
-			h = mux.match(muxKey{scheme, wildcard, path})
+			if u, ok := mux.redirectToPathSlash(wildcard, path, r.URL); ok {
+				return StatusHandler(StatusPermanentRedirect, u.String())
+			}
+			h = mux.match(wildcard, path)
 		}
 	}
+
+	if h == nil {
+		// Try empty host
+		if u, ok := mux.redirectToPathSlash("", path, r.URL); ok {
+			return StatusHandler(StatusPermanentRedirect, u.String())
+		}
+		h = mux.match("", path)
+	}
+
 	if h == nil {
 		h = NotFoundHandler()
 	}
+
 	return h
 }
 
@@ -234,48 +230,32 @@ func (mux *Mux) Handle(pattern string, handler Handler) {
 	mux.mu.Lock()
 	defer mux.mu.Unlock()
 
-	var key muxKey
+	var host, path string
-	if strings.HasPrefix(pattern, "//") {
-		// match any scheme
-		key.scheme = ""
-		pattern = pattern[2:]
-	} else {
-		// extract scheme
-		cut := strings.Index(pattern, "://")
-		if cut == -1 {
-			// default scheme of gemini
-			key.scheme = "gemini"
-		} else {
-			key.scheme = pattern[:cut]
-			pattern = pattern[cut+3:]
-		}
-	}
-
 	// extract hostname and path
 	cut := strings.Index(pattern, "/")
 	if cut == -1 {
-		key.host = pattern
+		host = pattern
-		key.path = "/"
+		path = "/"
 	} else {
-		key.host = pattern[:cut]
+		host = pattern[:cut]
-		key.path = pattern[cut:]
+		path = pattern[cut:]
 	}
 
 	// strip port from hostname
-	if hostname, _, err := net.SplitHostPort(key.host); err == nil {
+	if hostname, _, err := net.SplitHostPort(host); err == nil {
-		key.host = hostname
+		host = hostname
 	}
 
-	if _, exist := mux.m[key]; exist {
+	if _, exist := mux.m[hostpath{host, path}]; exist {
 		panic("gemini: multiple registrations for " + pattern)
 	}
 
 	if mux.m == nil {
-		mux.m = make(map[muxKey]Handler)
+		mux.m = make(map[hostpath]Handler)
 	}
-	mux.m[key] = handler
+	mux.m[hostpath{host, path}] = handler
-	e := muxEntry{handler, key}
+	e := muxEntry{handler, host, path}
-	if key.path[len(key.path)-1] == '/' {
+	if path[len(path)-1] == '/' {
 		mux.es = appendSorted(mux.es, e)
 	}
 }
@@ -283,9 +263,7 @@ func (mux *Mux) Handle(pattern string, handler Handler) {
 func appendSorted(es []muxEntry, e muxEntry) []muxEntry {
 	n := len(es)
 	i := sort.Search(n, func(i int) bool {
-		return len(es[i].key.scheme) < len(e.key.scheme) ||
+		return len(es[i].path) < len(e.path)
-			len(es[i].key.host) < len(es[i].key.host) ||
-			len(es[i].key.path) < len(e.key.path)
 	})
 	if i == n {
 		return append(es, e)

mux_test.go

@@ -2,6 +2,7 @@ package gemini
 
 import (
 	"context"
+	"io"
 	"net/url"
 	"testing"
 )
@@ -10,6 +11,221 @@ type nopHandler struct{}
 
 func (*nopHandler) ServeGemini(context.Context, ResponseWriter, *Request) {}
 
+type nopResponseWriter struct {
+	Status Status
+	Meta   string
+}
+
+func (w *nopResponseWriter) WriteHeader(status Status, meta string) {
+	w.Status = status
+	w.Meta = meta
+}
+
+func (nopResponseWriter) SetMediaType(mediatype string) {}
+func (nopResponseWriter) Write(b []byte) (int, error)   { return 0, io.EOF }
+func (nopResponseWriter) Flush() error                  { return nil }
+
+func TestMux(t *testing.T) {
+	type Test struct {
+		URL      string
+		Pattern  string
+		Redirect string
+		NotFound bool
+	}
+
+	tests := []struct {
+		Patterns []string
+		Tests    []Test
+	}{
+		{
+			Patterns: []string{"/a", "/b/", "/b/c/d", "/b/c/d/"},
+			Tests: []Test{
+				{
+					URL:      "gemini://example.com",
+					Redirect: "gemini://example.com/",
+				},
+				{
+					URL:      "gemini://example.com/",
+					NotFound: true,
+				},
+				{
+					URL:      "gemini://example.com/c",
+					NotFound: true,
+				},
+				{
+					URL:     "gemini://example.com/a",
+					Pattern: "/a",
+				},
+				{
+					URL:      "gemini://example.com/a/",
+					NotFound: true,
+				},
+				{
+					URL:      "gemini://example.com/b",
+					Redirect: "gemini://example.com/b/",
+				},
+				{
+					URL:     "gemini://example.com/b/",
+					Pattern: "/b/",
+				},
+				{
+					URL:     "gemini://example.com/b/c",
+					Pattern: "/b/",
+				},
+				{
+					URL:     "gemini://example.com/b/c/d",
+					Pattern: "/b/c/d",
+				},
+				{
+					URL:     "gemini://example.com/b/c/d/e/",
+					Pattern: "/b/c/d/",
+				},
+			},
+		},
+		{
+			Patterns: []string{
+				"/", "/a", "/b/",
+				"example.com", "example.com/a", "example.com/b/",
+				"*.example.com", "*.example.com/a", "*.example.com/b/",
+			},
+			Tests: []Test{
+				{
+					URL:     "gemini://example.net/",
+					Pattern: "/",
+				},
+				{
+					URL:     "gemini://example.net/a",
+					Pattern: "/a",
+				},
+				{
+					URL:      "gemini://example.net/b",
+					Redirect: "gemini://example.net/b/",
+				},
+				{
+					URL:     "gemini://example.net/b/",
+					Pattern: "/b/",
+				},
+				{
+					URL:     "gemini://example.com/",
+					Pattern: "example.com",
+				},
+				{
+					URL:      "gemini://example.com/b",
+					Redirect: "gemini://example.com/b/",
+				},
+				{
+					URL:     "gemini://example.com/b/",
+					Pattern: "example.com/b/",
+				},
+				{
+					URL:     "gemini://a.example.com/",
+					Pattern: "*.example.com",
+				},
+				{
+					URL:     "gemini://b.example.com/a",
+					Pattern: "*.example.com/a",
+				},
+				{
+					URL:      "gemini://c.example.com/b",
+					Redirect: "gemini://c.example.com/b/",
+				},
+				{
+					URL:     "gemini://d.example.com/b/",
+					Pattern: "*.example.com/b/",
+				},
+			},
+		},
+		{
+			Patterns: []string{"example.net", "*.example.org"},
+			Tests: []Test{
+				{
+					// The following redirect occurs as a result of cleaning
+					// the path provided to the Mux. This happens even if there
+					// are no matching handlers.
+					URL:      "gemini://example.com",
+					Redirect: "gemini://example.com/",
+				},
+				{
+					URL:      "gemini://example.com/",
+					NotFound: true,
+				},
+				{
+					URL:      "gemini://example.net",
+					Redirect: "gemini://example.net/",
+				},
+				{
+					URL:      "gemini://example.org/",
+					NotFound: true,
+				},
+				{
+					URL:      "gemini://gemini.example.org",
+					Redirect: "gemini://gemini.example.org/",
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		type handler struct {
+			nopHandler
+			Pattern string
+		}
+
+		mux := &Mux{}
+		for _, pattern := range test.Patterns {
+			mux.Handle(pattern, &handler{
+				Pattern: pattern,
+			})
+		}
+
+		for _, test := range test.Tests {
+			u, err := url.Parse(test.URL)
+			if err != nil {
+				panic(err)
+			}
+
+			req := &Request{URL: u}
+
+			h := mux.Handler(req)
+
+			if h, ok := h.(*handler); ok {
+				if h.Pattern != test.Pattern {
+					t.Errorf("wrong pattern for %q: expected %q, got %q", test.URL, test.Pattern, h.Pattern)
+				}
+				continue
+			}
+
+			// Check redirects and NotFounds
+			w := &nopResponseWriter{}
+			h.ServeGemini(context.Background(), w, req)
+
+			switch w.Status {
+			case StatusNotFound:
+				if !test.NotFound {
+					t.Errorf("expected pattern for %q, got NotFound", test.URL)
+				}
+
+			case StatusPermanentRedirect:
+				if test.Redirect == "" {
+					t.Errorf("expected pattern for %q, got redirect to %q", test.URL, w.Meta)
+					break
+				}
+
+				res, err := url.Parse(test.Redirect)
+				if err != nil {
+					panic(err)
+				}
+				if w.Meta != res.String() {
+					t.Errorf("bad redirect for %q: expected %q, got %q", test.URL, res.String(), w.Meta)
+				}
+
+			default:
+				t.Errorf("unexpected response for %q: %d %s", test.URL, w.Status, w.Meta)
+			}
+		}
+	}
+}
+
 func TestMuxMatch(t *testing.T) {
 	type Match struct {
 		URL string
@@ -21,7 +237,7 @@ func TestMuxMatch(t *testing.T) {
 		Matches []Match
 	}{
 		{
-			// scheme: gemini, hostname: *, path: /*
+			// hostname: *, path: /*
 			Pattern: "/",
 			Matches: []Match{
 				{"gemini://example.com/path", true},
@@ -34,7 +250,7 @@ func TestMuxMatch(t *testing.T) {
 			},
 		},
 		{
-			// scheme: gemini, hostname: *, path: /path
+			// hostname: *, path: /path
 			Pattern: "/path",
 			Matches: []Match{
 				{"gemini://example.com/path", true},
@@ -47,7 +263,7 @@ func TestMuxMatch(t *testing.T) {
 			},
 		},
 		{
-			// scheme: gemini, hostname: *, path: /subtree/*
+			// hostname: *, path: /subtree/*
 			Pattern: "/subtree/",
 			Matches: []Match{
 				{"gemini://example.com/subtree/", true},
@@ -62,7 +278,7 @@ func TestMuxMatch(t *testing.T) {
 			},
 		},
 		{
-			// scheme: gemini, hostname: example.com, path: /*
+			// hostname: example.com, path: /*
 			Pattern: "example.com",
 			Matches: []Match{
 				{"gemini://example.com/path", true},
@@ -75,7 +291,7 @@ func TestMuxMatch(t *testing.T) {
 			},
 		},
 		{
-			// scheme: gemini, hostname: example.com, path: /path
+			// hostname: example.com, path: /path
 			Pattern: "example.com/path",
 			Matches: []Match{
 				{"gemini://example.com/path", true},
@@ -88,7 +304,7 @@ func TestMuxMatch(t *testing.T) {
 			},
 		},
 		{
-			// scheme: gemini, hostname: example.com, path: /subtree/*
+			// hostname: example.com, path: /subtree/*
 			Pattern: "example.com/subtree/",
 			Matches: []Match{
 				{"gemini://example.com/subtree/", true},
@@ -102,170 +318,6 @@ func TestMuxMatch(t *testing.T) {
 				{"http://example.com/subtree/", false},
 			},
 		},
-		{
-			// scheme: http, hostname: example.com, path: /*
-			Pattern: "http://example.com",
-			Matches: []Match{
-				{"http://example.com/path", true},
-				{"http://example.com/", true},
-				{"http://example.com/path.gmi", true},
-				{"http://example.com/path/", true},
-				{"http://example.org/path", false},
-				{"gemini://example.com/path", false},
-				{"gemini://example.org/path", false},
-			},
-		},
-		{
-			// scheme: http, hostname: example.com, path: /path
-			Pattern: "http://example.com/path",
-			Matches: []Match{
-				{"http://example.com/path", true},
-				{"http://example.com/", false},
-				{"http://example.com/path.gmi", false},
-				{"http://example.com/path/", false},
-				{"http://example.org/path", false},
-				{"gemini://example.com/path", false},
-				{"gemini://example.org/path", false},
-			},
-		},
-		{
-			// scheme: http, hostname: example.com, path: /subtree/*
-			Pattern: "http://example.com/subtree/",
-			Matches: []Match{
-				{"http://example.com/subtree/", true},
-				{"http://example.com/subtree/nested/", true},
-				{"http://example.com/subtree/nested/file", true},
-				{"http://example.org/subtree/", false},
-				{"http://example.org/subtree/nested/", false},
-				{"http://example.org/subtree/nested/file", false},
-				{"http://example.com/subtree", false},
-				{"http://www.example.com/subtree/", false},
-				{"gemini://example.com/subtree/", false},
-			},
-		},
-		{
-			// scheme: *, hostname: example.com, path: /*
-			Pattern: "//example.com",
-			Matches: []Match{
-				{"gemini://example.com/path", true},
-				{"gemini://example.com/", true},
-				{"gemini://example.com/path.gmi", true},
-				{"gemini://example.com/path/", true},
-				{"gemini://example.org/path", false},
-				{"http://example.com/path", true},
-				{"http://example.org/path", false},
-			},
-		},
-		{
-			// scheme: *, hostname: example.com, path: /path
-			Pattern: "//example.com/path",
-			Matches: []Match{
-				{"gemini://example.com/path", true},
-				{"gemini://example.com/", false},
-				{"gemini://example.com/path.gmi", false},
-				{"gemini://example.com/path/", false},
-				{"gemini://example.org/path", false},
-				{"http://example.com/path", true},
-				{"http://example.org/path", false},
-			},
-		},
-		{
-			// scheme: *, hostname: example.com, path: /subtree/*
-			Pattern: "//example.com/subtree/",
-			Matches: []Match{
-				{"gemini://example.com/subtree/", true},
-				{"gemini://example.com/subtree/nested/", true},
-				{"gemini://example.com/subtree/nested/file", true},
-				{"gemini://example.org/subtree/", false},
-				{"gemini://example.org/subtree/nested/", false},
-				{"gemini://example.org/subtree/nested/file", false},
-				{"gemini://example.com/subtree", false},
-				{"gemini://www.example.com/subtree/", false},
-				{"http://example.com/subtree/", true},
-			},
-		},
-		{
-			// scheme: http, hostname: *, path: /*
-			Pattern: "http://",
-			Matches: []Match{
-				{"http://example.com/path", true},
-				{"http://example.com/", true},
-				{"http://example.com/path.gmi", true},
-				{"http://example.com/path/", true},
-				{"http://example.org/path", true},
-				{"gemini://example.com/path", false},
-				{"gemini://example.org/path", false},
-			},
-		},
-		{
-			// scheme: http, hostname: *, path: /path
-			Pattern: "http:///path",
-			Matches: []Match{
-				{"http://example.com/path", true},
-				{"http://example.com/", false},
-				{"http://example.com/path.gmi", false},
-				{"http://example.com/path/", false},
-				{"http://example.org/path", true},
-				{"gemini://example.com/path", false},
-				{"gemini://example.org/path", false},
-			},
-		},
-		{
-			// scheme: http, hostname: *, path: /subtree/*
-			Pattern: "http:///subtree/",
-			Matches: []Match{
-				{"http://example.com/subtree/", true},
-				{"http://example.com/subtree/nested/", true},
-				{"http://example.com/subtree/nested/file", true},
-				{"http://example.org/subtree/", true},
-				{"http://example.org/subtree/nested/", true},
-				{"http://example.org/subtree/nested/file", true},
-				{"http://example.com/subtree", false},
-				{"http://www.example.com/subtree/", true},
-				{"gemini://example.com/subtree/", false},
-			},
-		},
-		{
-			// scheme: *, hostname: *, path: /*
-			Pattern: "//",
-			Matches: []Match{
-				{"gemini://example.com/path", true},
-				{"gemini://example.com/", true},
-				{"gemini://example.com/path.gmi", true},
-				{"gemini://example.com/path/", true},
-				{"gemini://example.org/path", true},
-				{"http://example.com/path", true},
-				{"http://example.org/path", true},
-			},
-		},
-		{
-			// scheme: *, hostname: *, path: /path
-			Pattern: "///path",
-			Matches: []Match{
-				{"gemini://example.com/path", true},
-				{"gemini://example.com/", false},
-				{"gemini://example.com/path.gmi", false},
-				{"gemini://example.com/path/", false},
-				{"gemini://example.org/path", true},
-				{"http://example.com/path", true},
-				{"http://example.org/path", true},
-			},
-		},
-		{
-			// scheme: *, hostname: *, path: /subtree/*
-			Pattern: "///subtree/",
-			Matches: []Match{
-				{"gemini://example.com/subtree/", true},
-				{"gemini://example.com/subtree/nested/", true},
-				{"gemini://example.com/subtree/nested/file", true},
-				{"gemini://example.org/subtree/", true},
-				{"gemini://example.org/subtree/nested/", true},
-				{"gemini://example.org/subtree/nested/file", true},
-				{"gemini://example.com/subtree", false},
-				{"gemini://www.example.com/subtree/", true},
-				{"http://example.com/subtree/", true},
-			},
-		},
 		{
 			// scheme: gemini, hostname: *.example.com, path: /*
 			Pattern: "*.example.com",
@@ -277,25 +329,14 @@ func TestMuxMatch(t *testing.T) {
 				{"http://www.example.com/", false},
 			},
 		},
-		{
-			// scheme: http, hostname: *.example.com, path: /*
-			Pattern: "http://*.example.com",
-			Matches: []Match{
-				{"http://mail.example.com/", true},
-				{"http://www.example.com/index.gmi", true},
-				{"http://example.com/", false},
-				{"http://a.b.example.com/", false},
-				{"gemini://www.example.com/", false},
-			},
-		},
 	}
 
-	for i, test := range tests {
+	for _, test := range tests {
 		h := &nopHandler{}
 		var mux Mux
 		mux.Handle(test.Pattern, h)
 
-		for _, match := range tests[i].Matches {
+		for _, match := range test.Matches {
 			u, err := url.Parse(match.URL)
 			if err != nil {
 				panic(err)

text.go

@@ -125,8 +125,8 @@ func ParseLines(r io.Reader, handler func(Line)) error {
 				name = strings.TrimLeft(name, spacetab)
 				line = LineLink{url, name}
 			}
-		} else if strings.HasPrefix(text, "*") {
+		} else if strings.HasPrefix(text, "* ") {
-			text = text[1:]
+			text = text[2:]
 			text = strings.TrimLeft(text, spacetab)
 			line = LineListItem(text)
 		} else if strings.HasPrefix(text, "###") {