8 files changed, 361 insertions, 54 deletions

diff --git a/.gitignore b/.gitignore
index e036b02..fe92af3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,6 @@ dist
 *.bak
 coverage.txt
 
-gopherproxy
+gopherproxy.bin
 
 .vscode
diff --git a/Makefile b/Makefile
index 1d65cf0..75a8f2e 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,7 @@
 all: dev
 
 dev: build
-        ./gopherproxy -bind 127.0.0.1:8000
+        ./gopherproxy.bin -bind 127.0.0.1:8000
 
 build: clean
         sassc -t compressed css/main.scss assets/style.css
@@ -12,7 +12,7 @@ build: clean
         pyftsubset fonts/iosevka-term-ss03-regular.ttf --name-IDs+=0,4,6 --text-file=fonts/glyphs.txt --flavor='woff2' --output-file='assets/iosevka-term-ss03-regular.woff2'
         pyftsubset fonts/iosevka-aile-regular.ttf --name-IDs+=0,4,6 --text-file=fonts/glyphs.txt --flavor='woff' --with-zopfli --output-file='assets/iosevka-aile-regular.woff'
         pyftsubset fonts/iosevka-aile-regular.ttf --name-IDs+=0,4,6 --text-file=fonts/glyphs.txt --flavor='woff2' --output-file='assets/iosevka-aile-regular.woff2'
-        go build -o ./gopherproxy ./cmd/gopherproxy/main.go
+        go build -o ./gopherproxy.bin ./main.go
 
 profile:
         @go test -cpuprofile cpu.prof -memprofile mem.prof -v -bench .
diff --git a/go.mod b/go.mod
index 503bb87..6cde9a1 100644
--- a/go.mod
+++ b/go.mod
@@ -5,7 +5,6 @@ require (
         github.com/davidbyttow/govips v0.0.0-20190304175058-d272f04c0fea
         github.com/gobuffalo/packr/v2 v2.1.0
         github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
-        github.com/prologic/go-gopher v0.0.0-20181230133552-0c68ed5f58b0
         github.com/temoto/robotstxt v0.0.0-20180810133444-97ee4a9ee6ea
         golang.org/x/net v0.0.0-20190311183353-d8887717615a
         golang.org/x/text v0.3.0
diff --git a/gopherproxy.go b/gopherproxy/gopherproxy.go
index 8c0bb89..6556845 100644
--- a/gopherproxy.go
+++ b/gopherproxy/gopherproxy.go
@@ -11,6 +11,7 @@ import (
         "io/ioutil"
         "log"
         "mime"
+        "net"
         "net/http"
         "net/url"
         "regexp"
@@ -19,15 +20,13 @@ import (
         "golang.org/x/net/html/charset"
         "golang.org/x/text/transform"
 
-        "github.com/temoto/robotstxt"
-
-        "github.com/prologic/go-gopher"
-
-        "github.com/gobuffalo/packr/v2"
-
-        "github.com/davidbyttow/govips/pkg/vips"
+        "git.feuerfuchs.dev/Feuerfuchs/gopherproxy/gopherproxy/libgemini"
+        "git.feuerfuchs.dev/Feuerfuchs/gopherproxy/gopherproxy/libgopher"
 
         "github.com/NYTimes/gziphandler"
+        "github.com/davidbyttow/govips/pkg/vips"
+        "github.com/gobuffalo/packr/v2"
+        "github.com/temoto/robotstxt"
 )
 
 const (
@@ -63,10 +62,14 @@ func resolveURI(uri string, baseURL *url.URL) (resolvedURI string) {
                         return ""
                 }
                 adjustedURI := baseURL.ResolveReference(url)
+                path := adjustedURI.Path
+                if !strings.HasPrefix(path, "/") {
+                        path = "/" + path
+                }
                 if adjustedURI.Scheme == "gemini" {
-                        resolvedURI = "/gemini/" + adjustedURI.Host + adjustedURI.Path
+                        resolvedURI = "/gemini/" + adjustedURI.Host + path
                 } else if adjustedURI.Scheme == "gopher" {
-                        resolvedURI = "/gopher/" + adjustedURI.Host + adjustedURI.Path
+                        resolvedURI = "/gopher/" + adjustedURI.Host + path
                 } else {
                         resolvedURI = adjustedURI.String()
                 }
@@ -75,13 +78,13 @@ func resolveURI(uri string, baseURL *url.URL) (resolvedURI string) {
         return
 }
 
-func renderGopherDirectory(w http.ResponseWriter, tpl *template.Template, assetList AssetList, uri string, hostport string, d gopher.Directory) error {
+func renderGopherDirectory(w http.ResponseWriter, tpl *template.Template, assetList AssetList, uri string, hostport string, d libgopher.Directory) error {
         var title string
 
         out := make([]Item, len(d.Items))
 
         for i, x := range d.Items {
-                if x.Type == gopher.INFO && x.Selector == "TITLE" {
+                if x.Type == libgopher.INFO && x.Selector == "TITLE" {
                         title = x.Description
                         continue
                 }
@@ -91,7 +94,7 @@ func renderGopherDirectory(w http.ResponseWriter, tpl *template.Template, assetL
                         Type: x.Type.String(),
                 }
 
-                if x.Type == gopher.INFO {
+                if x.Type == libgopher.INFO {
                         out[i] = tr
                         continue
                 }
@@ -111,18 +114,19 @@ func renderGopherDirectory(w http.ResponseWriter, tpl *template.Template, assetL
                         }
                         tr.Link = template.URL(link)
                 } else {
-                        var hostport string
-                        if x.Port == 70 {
-                                hostport = x.Host
+                        var linkHostport string
+                        if x.Port != "70" {
+                                linkHostport = net.JoinHostPort(x.Host, x.Port)
                         } else {
-                                hostport = fmt.Sprintf("%s:%d", x.Host, x.Port)
+                                linkHostport = x.Host
                         }
+
                         path := url.PathEscape(x.Selector)
                         path = strings.Replace(path, "%2F", "/", -1)
                         tr.Link = template.URL(
                                 fmt.Sprintf(
                                         "/gopher/%s/%s%s",
-                                        hostport,
+                                        linkHostport,
                                         string(byte(x.Type)),
                                         path,
                                 ),
@@ -171,7 +175,7 @@ func parseGeminiDocument(body *bytes.Buffer, uri string, hostport string) (items
                         Text: line,
                 }
 
-                linkMatch := GeminiLinkPattern.FindStringSubmatch(line)
+                linkMatch := libgemini.LinkPattern.FindStringSubmatch(line)
                 if len(linkMatch) != 0 && linkMatch[0] != "" {
                         item.Type = ITEM_TYPE_GEMINI_LINK
                         item.Link = template.URL(resolveURI(linkMatch[1], baseURL))
@@ -254,7 +258,7 @@ func GopherHandler(tpl *template.Template, robotsdata *robotstxt.RobotsData, ass
                         title = fmt.Sprintf("%s/%s", hostport, uri)
                 }
 
-                res, err := gopher.Get(
+                res, err := libgopher.Get(
                         fmt.Sprintf(
                                 "gopher://%s/%s%s",
                                 hostport,
@@ -371,7 +375,7 @@ func GeminiHandler(tpl *template.Template, robotsdata *robotstxt.RobotsData, ass
                         title = fmt.Sprintf("%s/%s", hostport, uri)
                 }
 
-                res, err := GeminiGet(
+                res, err := libgemini.Get(
                         fmt.Sprintf(
                                 "gemini://%s/%s%s",
                                 hostport,
@@ -458,7 +462,7 @@ func GeminiHandler(tpl *template.Template, robotsdata *robotstxt.RobotsData, ass
                                 items   []Item
                         )
 
-                        if strings.HasPrefix(res.Header.Meta, MIME_GEMINI) {
+                        if strings.HasPrefix(res.Header.Meta, libgemini.MIME_GEMINI) {
                                 items = parseGeminiDocument(buf, uri, hostport)
                         } else {
                                 rawText = buf.String()
@@ -567,7 +571,7 @@ func ListenAndServe(bind, startpagefile string, robotsfile string, robotsdebug b
                 }
         }
 
-        box := packr.New("assets", "./assets")
+        box := packr.New("assets", "../assets")
 
         fontdataw, err := box.Find("iosevka-term-ss03-regular.woff")
         if err != nil {
diff --git a/libgemini.go b/gopherproxy/libgemini/libgemini.go
index 94744ba..303490c 100644
--- a/libgemini.go
+++ b/gopherproxy/libgemini/libgemini.go
@@ -1,11 +1,13 @@
-package gopherproxy
+package libgemini
 
 import (
         "bufio"
         "crypto/tls"
         "errors"
+        "fmt"
         "io"
         "mime"
+        "net"
         "net/url"
         "regexp"
         "strconv"
@@ -47,21 +49,21 @@ const (
 )
 
 var (
-        HeaderPattern     = regexp.MustCompile("^(\\d\\d)[ \\t]+(.*)$")
-        GeminiLinkPattern = regexp.MustCompile("^=>[ \\t]*([^ \\t]+)(?:[ \\t]+(.*))?$")
+        HeaderPattern = regexp.MustCompile("^(\\d\\d)[ \\t]+(.*)$")
+        LinkPattern   = regexp.MustCompile("^=>[ \\t]*([^ \\t]+)(?:[ \\t]+(.*))?$")
 )
 
-type GeminiHeader struct {
+type Header struct {
         Status int
         Meta   string
 }
 
-type GeminiResponse struct {
-        Header *GeminiHeader
+type Response struct {
+        Header *Header
         Body   io.Reader
 }
 
-func GeminiGet(uri string) (*GeminiResponse, error) {
+func Get(uri string) (*Response, error) {
         u, err := url.Parse(uri)
         if err != nil {
                 return nil, err
@@ -71,24 +73,14 @@ func GeminiGet(uri string) (*GeminiResponse, error) {
                 return nil, errors.New("invalid scheme for uri")
         }
 
-        var (
-                host string
-                port int
-        )
+        host := u.Hostname()
+        port := u.Port()
 
-        hostport := strings.Split(u.Host, ":")
-        if len(hostport) == 2 {
-                host = hostport[0]
-                n, err := strconv.ParseInt(hostport[1], 10, 32)
-                if err != nil {
-                        return nil, err
-                }
-                port = int(n)
-        } else {
-                host, port = hostport[0], 1965
+        if port == "" {
+                port = "1965"
         }
 
-        conn, err := tls.Dial("tcp", host+":"+strconv.Itoa(port), &tls.Config{
+        conn, err := tls.Dial("tcp", net.JoinHostPort(host, port), &tls.Config{
                 MinVersion:         tls.VersionTLS12,
                 InsecureSkipVerify: true,
         })
@@ -110,19 +102,19 @@ func GeminiGet(uri string) (*GeminiResponse, error) {
                 return nil, err
         }
 
-        header, err := ParseGeminiHeader(string(line))
+        header, err := ParseHeader(string(line))
         if err != nil {
                 conn.Close()
                 return nil, err
         }
 
-        return &GeminiResponse{
+        return &Response{
                 Header: header,
                 Body:   reader,
         }, nil
 }
 
-func ParseGeminiHeader(line string) (header *GeminiHeader, err error) {
+func ParseHeader(line string) (header *Header, err error) {
         matches := HeaderPattern.FindStringSubmatch(line)
 
         status, err := strconv.Atoi(matches[1])
@@ -136,7 +128,7 @@ func ParseGeminiHeader(line string) (header *GeminiHeader, err error) {
                 mediaType, params, err := mime.ParseMediaType(meta)
 
                 if err != nil {
-                        meta = DEFAULT_MIME + ";charset=" + DEFAULT_CHARSET
+                        meta = fmt.Sprintf("%s;charset=%s", DEFAULT_MIME, DEFAULT_CHARSET)
                 } else if strings.HasPrefix(mediaType, "text/") {
                         if _, ok := params["charset"]; !ok {
                                 meta += ";charset=" + DEFAULT_CHARSET
@@ -144,7 +136,7 @@ func ParseGeminiHeader(line string) (header *GeminiHeader, err error) {
                 }
         }
 
-        header = &GeminiHeader{
+        header = &Header{
                 Status: status,
                 Meta:   meta,
         }
diff --git a/gopherproxy/libgopher/libgopher.go b/gopherproxy/libgopher/libgopher.go
new file mode 100644
index 0000000..86d58ff
--- /dev/null
+++ b/gopherproxy/libgopher/libgopher.go
@@ -0,0 +1,312 @@
+package libgopher
+
+import (
+        "bufio"
+        "errors"
+        "io"
+        "log"
+        "net"
+        "net/url"
+        "strings"
+)
+
+// Item Types
+const (
+        FILE        = ItemType('0') // Item is a file
+        DIRECTORY   = ItemType('1') // Item is a directory
+        PHONEBOOK   = ItemType('2') // Item is a CSO phone-book server
+        ERROR       = ItemType('3') // Error
+        BINHEX      = ItemType('4') // Item is a BinHexed Macintosh file.
+        DOSARCHIVE  = ItemType('5') // Item is DOS binary archive of some sort. (*)
+        UUENCODED   = ItemType('6') // Item is a UNIX uuencoded file.
+        INDEXSEARCH = ItemType('7') // Item is an Index-Search server.
+        TELNET      = ItemType('8') // Item points to a text-based telnet session.
+        BINARY      = ItemType('9') // Item is a binary file! (*)
+
+        // (*) Client must read until the TCP connection is closed.
+
+        REDUNDANT = ItemType('+') // Item is a redundant server
+        TN3270    = ItemType('T') // Item points to a text-based tn3270 session.
+        GIF       = ItemType('g') // Item is a GIF format graphics file.
+        IMAGE     = ItemType('I') // Item is some kind of image file.
+
+        // non-standard
+        INFO  = ItemType('i') // Item is an informational message
+        HTML  = ItemType('h') // Item is a HTML document
+        AUDIO = ItemType('s') // Item is an Audio file
+        PNG   = ItemType('p') // Item is a PNG Image
+        DOC   = ItemType('d') // Item is a Document
+)
+
+const (
+        // END represents the terminator used in directory responses
+        END = byte('.')
+
+        // TAB is the delimiter used to separate item response parts
+        TAB = byte('\t')
+
+        // CRLF is the delimiter used per line of response item
+        CRLF = "\r\n"
+
+        // DEFAULT is the default item type
+        DEFAULT = BINARY
+)
+
+// ItemType represents the type of an item
+type ItemType byte
+
+// Return a human friendly represation of an ItemType
+func (it ItemType) String() string {
+        switch it {
+        case FILE:
+                return "TXT"
+        case DIRECTORY:
+                return "DIR"
+        case PHONEBOOK:
+                return "PHO"
+        case ERROR:
+                return "ERR"
+        case BINHEX:
+                return "HEX"
+        case DOSARCHIVE:
+                return "ARC"
+        case UUENCODED:
+                return "UUE"
+        case INDEXSEARCH:
+                return "QRY"
+        case TELNET:
+                return "TEL"
+        case BINARY:
+                return "BIN"
+        case REDUNDANT:
+                return "DUP"
+        case TN3270:
+                return "TN3"
+        case GIF:
+                return "GIF"
+        case IMAGE:
+                return "IMG"
+        case INFO:
+                return "NFO"
+        case HTML:
+                return "HTM"
+        case AUDIO:
+                return "SND"
+        case PNG:
+                return "PNG"
+        case DOC:
+                return "DOC"
+        default:
+                return "???"
+        }
+}
+
+// Item describes an entry in a directory listing.
+type Item struct {
+        Type        ItemType `json:"type"`
+        Description string   `json:"description"`
+        Selector    string   `json:"selector"`
+        Host        string   `json:"host"`
+        Port        string   `json:"port"`
+
+        // non-standard extensions (ignored by standard clients)
+        Extras []string `json:"extras"`
+}
+
+// ParseItem parses a line of text into an item
+func ParseItem(line string) (item *Item, err error) {
+        parts := strings.Split(strings.Trim(line, "\r\n"), "\t")
+
+        if len(parts[0]) < 1 {
+                return nil, errors.New("no item type: " + string(line))
+        }
+
+        item = &Item{
+                Type:        ItemType(parts[0][0]),
+                Description: string(parts[0][1:]),
+                Extras:      make([]string, 0),
+        }
+
+        // Selector
+        if len(parts) > 1 {
+                item.Selector = string(parts[1])
+        } else {
+                item.Selector = ""
+        }
+
+        // Host
+        if len(parts) > 2 {
+                item.Host = string(parts[2])
+        } else {
+                item.Host = "null.host"
+        }
+
+        // Port
+        if len(parts) > 3 {
+                item.Port = string(parts[3])
+        } else {
+                item.Port = "0"
+        }
+
+        // Extras
+        if len(parts) >= 4 {
+                for _, v := range parts[4:] {
+                        item.Extras = append(item.Extras, string(v))
+                }
+        }
+
+        return
+}
+
+func (i *Item) isDirectoryLike() bool {
+        switch i.Type {
+        case DIRECTORY:
+                return true
+        case INDEXSEARCH:
+                return true
+        default:
+                return false
+        }
+}
+
+// Directory representes a Gopher Menu of Items
+type Directory struct {
+        Items []*Item `json:"items"`
+}
+
+// Response represents a Gopher resource that
+// Items contains a non-empty array of Item(s)
+// for directory types, otherwise the Body
+// contains the fetched resource (file, image, etc).
+type Response struct {
+        Type ItemType
+        Dir  Directory
+        Body io.Reader
+}
+
+// Get fetches a Gopher resource by URI
+func Get(uri string) (*Response, error) {
+        u, err := url.Parse(uri)
+        if err != nil {
+                return nil, err
+        }
+
+        if u.Scheme != "gopher" {
+                return nil, errors.New("invalid scheme for uri")
+        }
+
+        host := u.Hostname()
+        port := u.Port()
+
+        if port == "" {
+                port = "70"
+        }
+
+        var (
+                Type     ItemType
+                Selector string
+        )
+
+        path := strings.TrimPrefix(u.Path, "/")
+        if len(path) > 2 {
+                Type = ItemType(path[0])
+                Selector = path[1:]
+                if u.RawQuery != "" {
+                        Selector += "\t" + u.RawQuery
+                }
+        } else if len(path) == 1 {
+                Type = ItemType(path[0])
+                Selector = ""
+        } else {
+                Type = ItemType(DIRECTORY)
+                Selector = ""
+        }
+
+        i := Item{Type: Type, Selector: Selector, Host: host, Port: port}
+        res := Response{Type: i.Type}
+
+        if i.isDirectoryLike() {
+                d, err := i.FetchDirectory()
+                if err != nil {
+                        return nil, err
+                }
+
+                res.Dir = d
+        } else {
+                reader, err := i.FetchFile()
+                if err != nil {
+                        return nil, err
+                }
+
+                res.Body = reader
+        }
+
+        return &res, nil
+}
+
+// FetchFile fetches data, not directory information.
+// Calling this on a DIRECTORY Item type
+// or unsupported type will return an error.
+func (i *Item) FetchFile() (io.Reader, error) {
+        if i.Type == DIRECTORY {
+                return nil, errors.New("cannot fetch a directory as a file")
+        }
+
+        conn, err := net.Dial("tcp", net.JoinHostPort(i.Host, i.Port))
+        if err != nil {
+                return nil, err
+        }
+
+        _, err = conn.Write([]byte(i.Selector + CRLF))
+        if err != nil {
+                conn.Close()
+                return nil, err
+        }
+
+        return conn, nil
+}
+
+// FetchDirectory fetches directory information, not data.
+// Calling this on an Item whose type is not DIRECTORY will return an error.
+func (i *Item) FetchDirectory() (Directory, error) {
+        if !i.isDirectoryLike() {
+                return Directory{}, errors.New("cannot fetch a file as a directory")
+        }
+
+        conn, err := net.Dial("tcp", net.JoinHostPort(i.Host, i.Port))
+        if err != nil {
+                return Directory{}, err
+        }
+
+        _, err = conn.Write([]byte(i.Selector + CRLF))
+        if err != nil {
+                return Directory{}, err
+        }
+
+        reader := bufio.NewReader(conn)
+        scanner := bufio.NewScanner(reader)
+        scanner.Split(bufio.ScanLines)
+
+        var items []*Item
+
+        for scanner.Scan() {
+                line := strings.Trim(scanner.Text(), "\r\n")
+
+                if len(line) == 0 {
+                        continue
+                }
+
+                if len(line) == 1 && line[0] == END {
+                        break
+                }
+
+                item, err := ParseItem(line)
+                if err != nil {
+                        log.Printf("Error parsing %q: %q", line, err)
+                        continue
+                }
+                items = append(items, item)
+        }
+
+        return Directory{items}, nil
+}
diff --git a/template.go b/gopherproxy/template.go
index 6b90cc0..6b90cc0 100644
--- a/template.go
+++ b/gopherproxy/template.go
diff --git a/cmd/gopherproxy/main.go b/main.go
index 6e6f48c..f5a82fe 100644
--- a/cmd/gopherproxy/main.go
+++ b/main.go
@@ -4,7 +4,7 @@ import (
         "flag"
         "log"
 
-        "git.feuerfuchs.dev/Feuerfuchs/gopherproxy"
+        "git.feuerfuchs.dev/Feuerfuchs/gopherproxy/gopherproxy"
 )
 
 var (