konbata/main.go

234 lines
4.8 KiB
Go
Raw Normal View History

2021-08-09 14:14:56 +00:00
package main
import (
"os"
"fmt"
"log"
"sort"
"time"
"errors"
"context"
"strings"
"net/url"
"crypto/x509"
"encoding/xml"
"path/filepath"
"git.sr.ht/~adnano/go-gemini"
"git.sr.ht/~adnano/go-gemini/tofu"
)
var (
hosts tofu.KnownHosts
hostsfile *tofu.HostWriter
)
func xdgDataHome() string {
if s, ok := os.LookupEnv("XDG_DATA_HOME"); ok {
return s
}
return filepath.Join(os.Getenv("HOME"), ".local", "share")
}
func init() {
path := filepath.Join(xdgDataHome(), "konbata", "known_hosts")
err := hosts.Load(path)
if err != nil {
log.Fatal(err)
}
hostsfile, err = tofu.OpenHostsFile(path)
if err != nil {
log.Fatal(err)
}
}
func trustCertificate(hostname string, cert *x509.Certificate) error {
host := tofu.NewHost(hostname, cert.Raw)
knownHost, ok := hosts.Lookup(hostname)
if ok {
// Check fingerprint
if knownHost.Fingerprint != host.Fingerprint {
return errors.New("fingerprint does not match!")
}
return nil
}
hosts.Add(host)
hostsfile.WriteHost(host)
return nil
}
func do(req *gemini.Request, via []*gemini.Request) (*gemini.Response, *gemini.Request, error) {
client := gemini.Client{
TrustCertificate: trustCertificate,
}
ctx := context.Background()
resp, err := client.Do(ctx, req)
if err != nil {
return resp, req, err
}
if resp.Status.Class() == gemini.StatusRedirect {
via = append(via, req)
if len(via) > 5 {
return resp, req, errors.New("too many redirects")
}
target, err := url.Parse(resp.Meta)
if err != nil {
return resp, req, err
}
if target.Scheme != "gemini" && target.Scheme != "" {
return resp, req, errors.New(fmt.Sprintf("tried to redirect to scheme %s", target.Scheme))
}
target = req.URL.ResolveReference(target)
redirect := *req
redirect.URL = target
return do(&redirect, via)
}
2021-08-10 06:09:51 +00:00
if resp.Status.Class() != gemini.StatusSuccess {
return resp, req, errors.New(fmt.Sprintf("%d %s", resp.Status, resp.Meta))
}
2021-08-09 14:14:56 +00:00
return resp, req, err
}
func main() {
if len(os.Args) == 0 {
fmt.Fprintf(os.Stderr, "Usage: konbata <url>\n")
os.Exit(1)
}
if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, "Usage: %s <url>\n", os.Args[0])
os.Exit(1)
}
req, err := gemini.NewRequest(os.Args[1])
if err != nil {
log.Fatal(err)
}
resp, req, err := do(req, nil)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
2021-08-09 17:35:24 +00:00
if resp.Meta != "text/gemini" && !strings.HasPrefix(resp.Meta, "text/gemini;") {
log.Fatal("mime type is not text/gemini")
}
2021-08-09 14:14:56 +00:00
aw := AtomWriter{
Title: "",
Items: nil,
}
gemini.ParseLines(resp.Body, aw.Handle)
sort.Sort(ByTime(aw.Items))
feed := &Feed{
XMLNS: "http://www.w3.org/2005/Atom",
Link: &FeedLink{
Href: req.URL.String(),
},
Id: req.URL.String(),
Entries: nil,
}
if aw.Title == "" {
feed.Title = req.URL.String()
} else {
feed.Title = aw.Title
}
if len(aw.Items) == 0 {
feed.Updated = time.Now().Format(time.RFC3339)
} else {
feed.Updated = aw.Items[0].Date.Format(time.RFC3339)
}
for i := len(aw.Items); i != 0; i-- {
item := aw.Items[i - 1]
link, err := req.URL.Parse(item.Link)
if err != nil {
log.Fatal(err)
}
feed.Entries = append(feed.Entries, &FeedEntry{
Title: item.Title,
Link: &EntryLink{
Href: link.String(),
Rel: "alternate",
},
Id: link.String(),
Updated: item.Date.Format(time.RFC3339),
})
}
2021-08-10 05:29:23 +00:00
out, err := xml.MarshalIndent(feed, "", " ")
if err != nil {
log.Fatal(err)
}
2021-08-09 14:14:56 +00:00
fmt.Println(string(out))
}
type Feed struct {
XMLName xml.Name `xml:"feed"`
XMLNS string `xml:"xmlns,attr"`
Title string `xml:"title"`
Link *FeedLink `xml:"link"`
Updated string `xml:"updated"`
Id string `xml:"id"`
Entries []*FeedEntry `xml:"entry"`
}
type FeedLink struct {
XMLName xml.Name `xml:"link"`
Href string `xml:"href,attr"`
}
type FeedEntry struct {
XMLName xml.Name `xml:"entry"`
Title string `xml:"title"`
Link *EntryLink `xml:"link"`
Id string `xml:"id"`
Updated string `xml:"updated"`
}
type EntryLink struct {
XMLName xml.Name `xml:"link"`
Href string `xml:"href,attr"`
Rel string `xml:"rel,attr"`
}
type FeedItem struct {
Date time.Time
Title string
Link string
}
type ByTime []FeedItem
func (a ByTime) Len() int {
return len(a)
}
func (a ByTime) Less(i, j int) bool {
return a[i].Date.Before(a[j].Date)
}
func (a ByTime) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
type AtomWriter struct {
Title string
Items []FeedItem
}
func (a *AtomWriter) Handle(line gemini.Line) {
switch line := line.(type) {
case gemini.LineLink:
runes := []rune(line.Name)
t, err := time.Parse("2006-01-02", string(runes[:10]))
if err == nil {
a.Items = append(a.Items, FeedItem{
Date: t,
Title: strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(string(runes[10:])), ":-")),
Link: string(line.URL),
})
}
case gemini.LineHeading1:
if a.Title == "" {
a.Title = string(line)
}
}
}