kobo-gemini/main.go

package main

import (
    "github.com/fogleman/gg"
    "github.com/shermp/go-fbink-v2/gofbink"
    "github.com/shermp/go-kobo-input/koboin"
    "image"
    "git.sr.ht/~adnano/go-gemini"
	"git.sr.ht/~adnano/go-gemini/tofu"
	"crypto/x509"
//	"time"
//	"bytes"
	"errors"
	"net/url"
	"golang.org/x/image/font"
	"bufio"
	"io/ioutil"
	"fmt"
	"time"
	"os"
	"log"
    "bytes"
    "github.com/golang/freetype/truetype"

)

var (
	hosts     tofu.KnownHosts
	hostsfile *tofu.HostWriter
	scanner   *bufio.Scanner
)

var height int = 1080
var width int = 1440 // TODO get from device instead of hardcoding

var f *truetype.Font
var face font.Face

// drawErrorBox prints the given error on screen, and only proceeds after touch input.
// Returns an error if drawing an error box (lol) fails.
// TODO make this work
func drawErrorBox(e error, fb *gofbink.FBInk, t *koboin.TouchDevice, opts *gofbink.FBInkConfig ) error {
	h := float64(height/2)
	w := float64(width)
	i := image.NewRGBA(image.Rect(width,0,width,height/2))
	dc := gg.NewContextForRGBA(i)
	dc.SetFontFace(face)
	dc.SetRGB(1, 1, 1)
	dc.Clear()
	dc.SetRGB(0, 0, 0)
	dc.DrawStringWrapped(e.Error(), h/2, w/2, 0.5, 0.5, float64(width), 1.0, gg.AlignCenter)
	fb.PrintRBGA(0, 0, i, opts)
	t.GetInput()
	return nil
}

func trustCertificate(hostname string, cert *x509.Certificate) error {
	host := tofu.NewHost(hostname, cert.Raw, cert.NotAfter)
	knownHost, ok := hosts.Lookup(hostname)
	if ok && time.Now().Before(knownHost.Expires) {
		// Check fingerprint
		if bytes.Equal(knownHost.Fingerprint, host.Fingerprint) {
			return nil
		}
		return errors.New("error: fingerprint does not match!")
    } else { // Expired cert or new host: TOFU
        hosts.Add(host)
        hostsfile.WriteHost(host)
        return nil
    }
    return errors.New("error: fingerprint does not match!")
}

func do(req *gemini.Request, via []*gemini.Request) (*gemini.Response, error) {
	client := gemini.Client{
		TrustCertificate: trustCertificate,
	}
	resp, err := client.Do(req)
	if err != nil {
		return resp, err
	}

	switch resp.Status.Class() {
    case gemini.StatusClassInput: // TODO implement input
	/*	input, ok := getInput(resp.Meta, resp.Status == gemini.StatusSensitiveInput)
		if !ok {
			break
		}
		req.URL.ForceQuery = true
		req.URL.RawQuery = gemini.QueryEscape(input)
		return do(req, via) */


	case gemini.StatusClassRedirect:
		via = append(via, req)
		if len(via) > 5 {
			return resp, errors.New("too many redirects")
		}

		target, err := url.Parse(resp.Meta)
		if err != nil {
			return resp, err
		}
		target = req.URL.ResolveReference(target)
		redirect := *req
		redirect.URL = target
		return do(&redirect, via)
	}

	return resp, err
}

func main() {
    // Framebuffer setup
	fbinkOpts := gofbink.FBInkConfig{}
	rOpts := gofbink.RestrictedConfig{}
	fb := gofbink.New(&fbinkOpts, &rOpts)
	fb.Open()
    defer fb.Close()
	fb.Init(&fbinkOpts)
    fb.ClearScreen(&fbinkOpts)
    fb.Refresh(0,0,0,0, gofbink.DitherPassthrough, &fbinkOpts)

    // Touchscreen setup
    touchPath := "/dev/input/event1"
    t := koboin.New(touchPath, height, width)
	if t == nil {
	    return
	}
	defer t.Close()
	
	// Logging setup
	var logFile, err= os.Create("/mnt/onboard/gemini.log")
	var logger *log.Logger = log.New(logFile, "gemini", log.LstdFlags )
	defer logFile.Close()

	path := "/mnt/onboard/.adds/gemini/known-hosts" // TODO don't hardcode
	
	// Reload or create known hosts file
	if _, err := os.Stat(path); os.IsNotExist(err) {
	  os.Create(path)
	}
    err = hosts.Load(path)
	if err != nil {
		drawErrorBox(err, fb, t, &fbinkOpts)
		logger.Fatal(err)
	}

	hostsfile, err = tofu.NewHostsFile(path)
	if err != nil {
		fb.Println(err)
		logger.Fatal(err)
	}
	
	// Load Fonts, Create font face
    b, err := ioutil.ReadFile("/mnt/onboard/.adds/gemini/NotoSerif.ttf")
    if err != nil {
        logger.Println(err)
        return
    }
    f, err := truetype.Parse(b)
    if err != nil {
        logger.Println(err)
        return
    }
    face = truetype.NewFace(f, &truetype.Options{Size:32})
    url := "gemini://gemini.circumlunar.space"
	req, err := gemini.NewRequest(url)
	if err != nil {
		drawErrorBox(err, fb, t, &fbinkOpts)
		logger.Fatal(err)
	}
	resp, err := do(req, nil)
	if err != nil {
		drawErrorBox(err, fb, t, &fbinkOpts)
		logger.Fatal(err)
	}
	defer resp.Body.Close()

	// Handle response
	if resp.Status.Class() == gemini.StatusClassSuccess {
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			drawErrorBox(err, fb, t, &fbinkOpts)
			logger.Fatal(err)
		}
		fb.Println(string(body))
	} else {
		fb.Println(fmt.Sprintf("%d %s\n", resp.Status, resp.Meta))
	}

	for {
        x, y, err := t.GetInput()
		if err != nil {
			continue
		}
        if x < 100 && y < 100 {
        	fb.Println("Exiting...")
            break
        }
    }
    hostsfile.Close()
}