honk/activity.go

//
// Copyright (c) 2019 Ted Unangst <tedu@tedunangst.com>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package main

import (
	"bytes"
	"crypto/rsa"
	"database/sql"
	"fmt"
	"io"
	"log"
	notrand "math/rand"
	"net/http"
	"net/url"
	"os"
	"strings"
	"sync"
	"time"

	"humungus.tedunangst.com/r/webs/httpsig"
	"humungus.tedunangst.com/r/webs/image"
	"humungus.tedunangst.com/r/webs/junk"
)

var theonetruename = `application/ld+json; profile="https://www.w3.org/ns/activitystreams"`
var thefakename = `application/activity+json`
var falsenames = []string{
	`application/ld+json`,
	`application/activity+json`,
}
var itiswhatitis = "https://www.w3.org/ns/activitystreams"
var thewholeworld = "https://www.w3.org/ns/activitystreams#Public"

func friendorfoe(ct string) bool {
	ct = strings.ToLower(ct)
	for _, at := range falsenames {
		if strings.HasPrefix(ct, at) {
			return true
		}
	}
	return false
}

func PostJunk(keyname string, key *rsa.PrivateKey, url string, j junk.Junk) error {
	var buf bytes.Buffer
	j.Write(&buf)
	return PostMsg(keyname, key, url, buf.Bytes())
}

func PostMsg(keyname string, key *rsa.PrivateKey, url string, msg []byte) error {
	client := http.DefaultClient
	req, err := http.NewRequest("POST", url, bytes.NewReader(msg))
	if err != nil {
		return err
	}
	req.Header.Set("User-Agent", "honksnonk/5.0; "+serverName)
	req.Header.Set("Content-Type", theonetruename)
	httpsig.SignRequest(keyname, key, req, msg)
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	resp.Body.Close()
	switch resp.StatusCode {
	case 200:
	case 201:
	case 202:
	default:
		return fmt.Errorf("http post status: %d", resp.StatusCode)
	}
	log.Printf("successful post: %s %d", url, resp.StatusCode)
	return nil
}

func GetJunk(url string) (junk.Junk, error) {
	return GetJunkTimeout(url, 30*time.Second)
}

func GetJunkFast(url string) (junk.Junk, error) {
	return GetJunkTimeout(url, 5*time.Second)
}

func GetJunkHardMode(url string) (junk.Junk, error) {
	j, err := GetJunk(url)
	if err != nil {
		emsg := err.Error()
		if emsg == "http get status: 502" || strings.Contains(emsg, "timeout") {
			log.Printf("trying again after error: %s", emsg)
			time.Sleep(time.Duration(60+notrand.Int63n(60)) * time.Second)
			j, err = GetJunk(url)
			if err != nil {
				log.Printf("still couldn't get it")
			} else {
				log.Printf("retry success!")
			}
		}
	}
	return j, err
}

func GetJunkTimeout(url string, timeout time.Duration) (junk.Junk, error) {
	at := thefakename
	if strings.Contains(url, ".well-known/webfinger?resource") {
		at = "application/jrd+json"
	}
	return junk.Get(url, junk.GetArgs{
		Accept:  at,
		Agent:   "honksnonk/5.0; " + serverName,
		Timeout: timeout,
	})
}

func savedonk(url string, name, media string, localize bool) *Donk {
	if url == "" {
		return nil
	}
	var donk Donk
	row := stmtFindFile.QueryRow(url)
	err := row.Scan(&donk.FileID)
	if err == nil {
		return &donk
	}
	log.Printf("saving donk: %s", url)
	if err != nil && err != sql.ErrNoRows {
		log.Printf("error querying: %s", err)
	}
	xid := xfiltrate()
	data := []byte{}
	if localize {
		resp, err := http.Get(url)
		if err != nil {
			log.Printf("error fetching %s: %s", url, err)
			localize = false
			goto saveit
		}
		defer resp.Body.Close()
		if resp.StatusCode != 200 {
			localize = false
			goto saveit
		}
		var buf bytes.Buffer
		io.Copy(&buf, resp.Body)

		data = buf.Bytes()
		if strings.HasPrefix(media, "image") {
			img, err := image.Vacuum(&buf,
				image.Params{LimitSize: 4800 * 4800, MaxWidth: 2048, MaxHeight: 2048})
			if err != nil {
				log.Printf("unable to decode image: %s", err)
				localize = false
				data = []byte{}
				goto saveit
			}
			data = img.Data
			media = "image/" + img.Format
		} else if len(data) > 100000 {
			log.Printf("not saving large attachment")
			localize = false
			data = []byte{}
		}
	}
saveit:
	res, err := stmtSaveFile.Exec(xid, name, url, media, localize, data)
	if err != nil {
		log.Printf("error saving file %s: %s", url, err)
		return nil
	}
	donk.FileID, _ = res.LastInsertId()
	return &donk
}

func iszonked(userid int64, xid string) bool {
	row := stmtFindZonk.QueryRow(userid, xid)
	var id int64
	err := row.Scan(&id)
	if err == nil {
		return true
	}
	if err != sql.ErrNoRows {
		log.Printf("err querying zonk: %s", err)
	}
	return false
}

func needxonk(user *WhatAbout, x *Honk) bool {
	if x.What == "eradicate" {
		return true
	}
	if thoudostbitethythumb(user.ID, x.Audience, x.XID) {
		log.Printf("not saving thumb biter? %s via %s", x.XID, x.Honker)
		return false
	}
	return needxonkid(user, x.XID)
}
func needxonkid(user *WhatAbout, xid string) bool {
	if strings.HasPrefix(xid, user.URL+"/") {
		return false
	}
	if iszonked(user.ID, xid) {
		log.Printf("already zonked: %s", xid)
		return false
	}
	row := stmtFindXonk.QueryRow(user.ID, xid)
	var id int64
	err := row.Scan(&id)
	if err == nil {
		return false
	}
	if err != sql.ErrNoRows {
		log.Printf("err querying xonk: %s", err)
	}
	return true
}

func savexonk(user *WhatAbout, x *Honk) {
	if x.What == "eradicate" {
		log.Printf("eradicating %s by %s", x.XID, x.Honker)
		xonk := getxonk(user.ID, x.XID)
		if xonk != nil {
			_, err := stmtZonkDonks.Exec(xonk.ID)
			if err != nil {
				log.Printf("error eradicating: %s", err)
			}
			_, err = stmtZonkIt.Exec(user.ID, x.XID)
			if err != nil {
				log.Printf("error eradicating: %s", err)
			}
		}
		_, err := stmtSaveZonker.Exec(user.ID, x.XID, "zonk")
		if err != nil {
			log.Printf("error eradicating: %s", err)
		}
		return
	}
	log.Printf("saving xonk: %s", x.XID)
	dt := x.Date.UTC().Format(dbtimeformat)
	aud := strings.Join(x.Audience, " ")
	whofore := 0
	if strings.Contains(aud, user.URL) {
		whofore = 1
	}
	go prehandle(x.Honker)
	go prehandle(x.Oonker)
	res, err := stmtSaveHonk.Exec(x.UserID, x.What, x.Honker, x.XID, x.RID, dt, x.URL, aud,
		x.Noise, x.Convoy, whofore, "html", x.Precis, x.Oonker, 0)
	if err != nil {
		log.Printf("err saving xonk: %s", err)
		return
	}
	x.ID, _ = res.LastInsertId()
	for _, d := range x.Donks {
		_, err = stmtSaveDonk.Exec(x.ID, d.FileID)
		if err != nil {
			log.Printf("err saving donk: %s", err)
			return
		}
	}
}

type Box struct {
	In     string
	Out    string
	Shared string
}

var boxofboxes = make(map[string]*Box)
var boxlock sync.Mutex
var boxinglock sync.Mutex

func getboxes(ident string) (*Box, error) {
	boxlock.Lock()
	b, ok := boxofboxes[ident]
	boxlock.Unlock()
	if ok {
		return b, nil
	}

	boxinglock.Lock()
	defer boxinglock.Unlock()

	boxlock.Lock()
	b, ok = boxofboxes[ident]
	boxlock.Unlock()
	if ok {
		return b, nil
	}

	var info string
	row := stmtGetXonker.QueryRow(ident, "boxes")
	err := row.Scan(&info)
	if err != nil {
		j, err := GetJunk(ident)
		if err != nil {
			return nil, err
		}
		inbox, _ := j.GetString("inbox")
		outbox, _ := j.GetString("outbox")
		sbox, _ := j.FindString([]string{"endpoints", "sharedInbox"})
		b = &Box{In: inbox, Out: outbox, Shared: sbox}
		if inbox != "" {
			m := strings.Join([]string{inbox, outbox, sbox}, " ")
			_, err = stmtSaveXonker.Exec(ident, m, "boxes")
			if err != nil {
				log.Printf("error saving boxes: %s", err)
			}
		}
	} else {
		m := strings.Split(info, " ")
		b = &Box{In: m[0], Out: m[1], Shared: m[2]}
	}

	boxlock.Lock()
	boxofboxes[ident] = b
	boxlock.Unlock()
	return b, nil
}

func gimmexonks(user *WhatAbout, outbox string) {
	log.Printf("getting outbox: %s", outbox)
	j, err := GetJunk(outbox)
	if err != nil {
		log.Printf("error getting outbox: %s", err)
		return
	}
	t, _ := j.GetString("type")
	origin := originate(outbox)
	if t == "OrderedCollection" {
		items, _ := j.GetArray("orderedItems")
		if items == nil {
			obj, ok := j.GetMap("first")
			if ok {
				items, _ = obj.GetArray("orderedItems")
			} else {
				page1, _ := j.GetString("first")
				j, err = GetJunk(page1)
				if err != nil {
					log.Printf("error gettings page1: %s", err)
					return
				}
				items, _ = j.GetArray("orderedItems")
			}
		}
		if len(items) > 20 {
			items = items[0:20]
		}
		for i, j := 0, len(items)-1; i < j; i, j = i+1, j-1 {
			items[i], items[j] = items[j], items[i]
		}
		for _, item := range items {
			obj, ok := item.(junk.Junk)
			if !ok {
				continue
			}
			xonk := xonkxonk(user, obj, origin)
			if xonk != nil {
				savexonk(user, xonk)
			}
		}
	}
}

func peeppeep() {
	user, _ := butwhatabout("htest")
	honkers := gethonkers(user.ID)
	for _, f := range honkers {
		if f.Flavor != "peep" {
			continue
		}
		log.Printf("getting updates: %s", f.XID)
		box, err := getboxes(f.XID)
		if err != nil {
			log.Printf("error getting outbox: %s", err)
			continue
		}
		gimmexonks(user, box.Out)
	}
}
func whosthere(xid string) ([]string, string) {
	obj, err := GetJunk(xid)
	if err != nil {
		log.Printf("error getting remote xonk: %s", err)
		return nil, ""
	}
	convoy, _ := obj.GetString("context")
	if convoy == "" {
		convoy, _ = obj.GetString("conversation")
	}
	return newphone(nil, obj), convoy
}

func newphone(a []string, obj junk.Junk) []string {
	for _, addr := range []string{"to", "cc", "attributedTo"} {
		who, _ := obj.GetString(addr)
		if who != "" {
			a = append(a, who)
		}
		whos, _ := obj.GetArray(addr)
		for _, w := range whos {
			who, _ := w.(string)
			if who != "" {
				a = append(a, who)
			}
		}
	}
	return a
}

func extractattrto(obj junk.Junk) string {
	who, _ := obj.GetString("attributedTo")
	if who != "" {
		return who
	}
	o, ok := obj.GetMap("attributedTo")
	if ok {
		id, ok := o.GetString("id")
		if ok {
			return id
		}
	}
	arr, _ := obj.GetArray("attributedTo")
	for _, a := range arr {
		o, ok := a.(junk.Junk)
		if ok {
			t, _ := o.GetString("type")
			id, _ := o.GetString("id")
			if t == "Person" || t == "" {
				return id
			}
		}
	}
	return ""
}

func consumeactivity(user *WhatAbout, j junk.Junk, origin string) {
	xonk := xonkxonk(user, j, origin)
	if xonk != nil {
		savexonk(user, xonk)
	}
}

func xonkxonk(user *WhatAbout, item junk.Junk, origin string) *Honk {
	depth := 0
	maxdepth := 10
	currenttid := ""
	var xonkxonkfn func(item junk.Junk, origin string) *Honk

	saveoneup := func(xid string) {
		log.Printf("getting oneup: %s", xid)
		if depth >= maxdepth {
			log.Printf("in too deep")
			return
		}
		obj, err := GetJunkHardMode(xid)
		if err != nil {
			log.Printf("error getting oneup: %s: %s", xid, err)
			return
		}
		depth++
		xonk := xonkxonkfn(obj, originate(xid))
		if xonk != nil {
			savexonk(user, xonk)
		}
		depth--
	}

	xonkxonkfn = func(item junk.Junk, origin string) *Honk {
		// id, _ := item.GetString( "id")
		what, _ := item.GetString("type")
		dt, _ := item.GetString("published")

		var audience []string
		var err error
		var xid, rid, url, content, precis, convoy, oonker string
		var obj junk.Junk
		var ok bool
		switch what {
		case "Announce":
			obj, ok = item.GetMap("object")
			if ok {
				xid, _ = obj.GetString("id")
			} else {
				xid, _ = item.GetString("object")
			}
			if !needxonkid(user, xid) {
				return nil
			}
			log.Printf("getting bonk: %s", xid)
			obj, err = GetJunkHardMode(xid)
			if err != nil {
				log.Printf("error getting bonk: %s: %s", xid, err)
			}
			origin = originate(xid)
			what = "bonk"
		case "Create":
			obj, ok = item.GetMap("object")
			if !ok {
				xid, _ = obj.GetString("object")
				log.Printf("getting created honk: %s", xid)
				obj, err = GetJunkHardMode(xid)
				if err != nil {
					log.Printf("error getting creation: %s", err)
				}
			}
			what = "honk"
		case "Delete":
			obj, _ = item.GetMap("object")
			xid, _ = item.GetString("object")
			what = "eradicate"
		case "Read":
			xid, ok = item.GetString("object")
			if ok {
				if !needxonkid(user, xid) {
					log.Printf("don't need read obj: %s", xid)
					return nil
				}
				obj, err = GetJunkHardMode(xid)
				if err != nil {
					log.Printf("error getting read: %s", err)
					return nil
				}
				return xonkxonkfn(obj, originate(xid))
			}
			return nil
		case "Video":
			fallthrough
		case "Question":
			fallthrough
		case "Note":
			fallthrough
		case "Article":
			fallthrough
		case "Page":
			obj = item
			what = "honk"
		default:
			log.Printf("unknown activity: %s", what)
			fd, _ := os.OpenFile("savedinbox.json", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
			item.Write(fd)
			io.WriteString(fd, "\n")
			fd.Close()
			return nil
		}

		var xonk Honk
		who, _ := item.GetString("actor")
		if obj != nil {
			if who == "" {
				who = extractattrto(obj)
			}
			oonker = extractattrto(obj)
			ot, _ := obj.GetString("type")
			url, _ = obj.GetString("url")
			if ot == "Tombstone" {
				xid, _ = obj.GetString("id")
			} else {
				audience = newphone(audience, obj)
				xid, _ = obj.GetString("id")
				precis, _ = obj.GetString("summary")
				if precis == "" {
					precis, _ = obj.GetString("name")
				}
				content, _ = obj.GetString("content")
				if !strings.HasPrefix(content, "<p>") {
					content = "<p>" + content
				}
				sens, _ := obj["sensitive"].(bool)
				if sens && precis == "" {
					precis = "unspecified horror"
				}
				rid, ok = obj.GetString("inReplyTo")
				if !ok {
					robj, ok := obj.GetMap("inReplyTo")
					if ok {
						rid, _ = robj.GetString("id")
					}
				}
				convoy, _ = obj.GetString("context")
				if convoy == "" {
					convoy, _ = obj.GetString("conversation")
				}
				if ot == "Question" {
					if what == "honk" {
						what = "qonk"
					}
					content += "<ul>"
					ans, _ := obj.GetArray("oneOf")
					for _, ai := range ans {
						a, ok := ai.(junk.Junk)
						if !ok {
							continue
						}
						as, _ := a.GetString("name")
						content += "<li>" + as
					}
					ans, _ = obj.GetArray("anyOf")
					for _, ai := range ans {
						a, ok := ai.(junk.Junk)
						if !ok {
							continue
						}
						as, _ := a.GetString("name")
						content += "<li>" + as
					}
					content += "</ul>"
				}
				if what == "honk" && rid != "" {
					what = "tonk"
				}
			}
			atts, _ := obj.GetArray("attachment")
			for i, atti := range atts {
				att, ok := atti.(junk.Junk)
				if !ok {
					continue
				}
				at, _ := att.GetString("type")
				mt, _ := att.GetString("mediaType")
				u, _ := att.GetString("url")
				name, _ := att.GetString("name")
				localize := false
				if i > 4 {
					log.Printf("excessive attachment: %s", at)
				} else if at == "Document" || at == "Image" {
					mt = strings.ToLower(mt)
					log.Printf("attachment: %s %s", mt, u)
					if mt == "text/plain" || strings.HasPrefix(mt, "image") {
						localize = true
					}
				} else {
					log.Printf("unknown attachment: %s", at)
				}
				donk := savedonk(u, name, mt, localize)
				if donk != nil {
					xonk.Donks = append(xonk.Donks, donk)
				}
			}
			tags, _ := obj.GetArray("tag")
			for _, tagi := range tags {
				tag, ok := tagi.(junk.Junk)
				if !ok {
					continue
				}
				tt, _ := tag.GetString("type")
				name, _ := tag.GetString("name")
				if tt == "Emoji" {
					icon, _ := tag.GetMap("icon")
					mt, _ := icon.GetString("mediaType")
					if mt == "" {
						mt = "image/png"
					}
					u, _ := icon.GetString("url")
					donk := savedonk(u, name, mt, true)
					if donk != nil {
						xonk.Donks = append(xonk.Donks, donk)
					}
				}
			}
		}
		if originate(xid) != origin {
			log.Printf("original sin: %s <> %s", xid, origin)
			item.Write(os.Stdout)
			return nil
		}
		audience = append(audience, who)

		audience = oneofakind(audience)

		if currenttid == "" {
			currenttid = convoy
		}

		if oonker == who {
			oonker = ""
		}
		xonk.UserID = user.ID
		xonk.What = what
		xonk.Honker = who
		xonk.XID = xid
		xonk.RID = rid
		xonk.Date, _ = time.Parse(time.RFC3339, dt)
		xonk.URL = url
		xonk.Noise = content
		xonk.Precis = precis
		xonk.Audience = audience
		xonk.Oonker = oonker

		if needxonk(user, &xonk) {
			if rid != "" {
				if needxonkid(user, rid) {
					saveoneup(rid)
				}
			}
			if convoy == "" {
				convoy = currenttid
			}
			xonk.Convoy = convoy
			return &xonk
		}
		return nil
	}

	return xonkxonkfn(item, origin)
}

func rubadubdub(user *WhatAbout, req junk.Junk) {
	xid, _ := req.GetString("id")
	actor, _ := req.GetString("actor")
	j := junk.New()
	j["@context"] = itiswhatitis
	j["id"] = user.URL + "/dub/" + url.QueryEscape(xid)
	j["type"] = "Accept"
	j["actor"] = user.URL
	j["to"] = actor
	j["published"] = time.Now().UTC().Format(time.RFC3339)
	j["object"] = req

	var buf bytes.Buffer
	j.Write(&buf)
	msg := buf.Bytes()

	deliverate(0, user.Name, actor, msg)
}

func itakeitallback(user *WhatAbout, xid string) {
	j := junk.New()
	j["@context"] = itiswhatitis
	j["id"] = user.URL + "/unsub/" + url.QueryEscape(xid)
	j["type"] = "Undo"
	j["actor"] = user.URL
	j["to"] = xid
	f := junk.New()
	f["id"] = user.URL + "/sub/" + url.QueryEscape(xid)
	f["type"] = "Follow"
	f["actor"] = user.URL
	f["to"] = xid
	f["object"] = xid
	j["object"] = f
	j["published"] = time.Now().UTC().Format(time.RFC3339)

	var buf bytes.Buffer
	j.Write(&buf)
	msg := buf.Bytes()

	deliverate(0, user.Name, xid, msg)
}

func subsub(user *WhatAbout, xid string) {
	j := junk.New()
	j["@context"] = itiswhatitis
	j["id"] = user.URL + "/sub/" + url.QueryEscape(xid)
	j["type"] = "Follow"
	j["actor"] = user.URL
	j["to"] = xid
	j["object"] = xid
	j["published"] = time.Now().UTC().Format(time.RFC3339)

	var buf bytes.Buffer
	j.Write(&buf)
	msg := buf.Bytes()

	deliverate(0, user.Name, xid, msg)
}

func jonkjonk(user *WhatAbout, h *Honk) (junk.Junk, junk.Junk) {
	dt := h.Date.Format(time.RFC3339)
	var jo junk.Junk
	j := junk.New()
	j["id"] = user.URL + "/" + h.What + "/" + shortxid(h.XID)
	j["actor"] = user.URL
	j["published"] = dt
	if h.Public {
		j["to"] = []string{h.Audience[0], user.URL + "/followers"}
	} else {
		j["to"] = h.Audience[0]
	}
	if len(h.Audience) > 1 {
		j["cc"] = h.Audience[1:]
	}

	switch h.What {
	case "tonk":
		fallthrough
	case "honk":
		j["type"] = "Create"

		jo = junk.New()
		jo["id"] = h.XID
		jo["type"] = "Note"
		jo["published"] = dt
		jo["url"] = h.XID
		jo["attributedTo"] = user.URL
		if h.RID != "" {
			jo["inReplyTo"] = h.RID
		}
		if h.Convoy != "" {
			jo["context"] = h.Convoy
			jo["conversation"] = h.Convoy
		}
		jo["to"] = h.Audience[0]
		if len(h.Audience) > 1 {
			jo["cc"] = h.Audience[1:]
		}
		if !h.Public {
			jo["directMessage"] = true
		}
		jo["summary"] = h.Precis
		jo["content"] = mentionize(h.Noise)
		if strings.HasPrefix(h.Precis, "DZ:") {
			jo["sensitive"] = true
		}

		var replies []string
		for _, reply := range h.Replies {
			replies = append(replies, reply.XID)
		}
		if len(replies) > 0 {
			jr := junk.New()
			jr["type"] = "Collection"
			jr["totalItems"] = len(replies)
			jr["items"] = replies
			jo["replies"] = jr
		}

		var tags []junk.Junk
		g := bunchofgrapes(h.Noise)
		for _, m := range g {
			t := junk.New()
			t["type"] = "Mention"
			t["name"] = m.who
			t["href"] = m.where
			tags = append(tags, t)
		}
		ooo := ontologies(h.Noise)
		for _, o := range ooo {
			t := junk.New()
			t["type"] = "Hashtag"
			t["name"] = o
			tags = append(tags, t)
		}
		herd := herdofemus(h.Noise)
		for _, e := range herd {
			t := junk.New()
			t["id"] = e.ID
			t["type"] = "Emoji"
			t["name"] = e.Name
			i := junk.New()
			i["type"] = "Image"
			i["mediaType"] = "image/png"
			i["url"] = e.ID
			t["icon"] = i
			tags = append(tags, t)
		}
		if len(tags) > 0 {
			jo["tag"] = tags
		}
		var atts []junk.Junk
		for _, d := range h.Donks {
			if re_emus.MatchString(d.Name) {
				continue
			}
			jd := junk.New()
			jd["mediaType"] = d.Media
			jd["name"] = d.Name
			jd["type"] = "Document"
			jd["url"] = d.URL
			atts = append(atts, jd)
		}
		if len(atts) > 0 {
			jo["attachment"] = atts
		}
		j["object"] = jo
	case "bonk":
		j["type"] = "Announce"
		if h.Convoy != "" {
			j["context"] = h.Convoy
		}
		j["object"] = h.XID
	case "zonk":
		j["type"] = "Delete"
		j["object"] = h.XID
	case "ack":
		j["type"] = "Read"
		j["object"] = h.XID
	case "deack":
		j["type"] = "Ignore"
		j["object"] = h.XID
	}

	return j, jo
}

func honkworldwide(user *WhatAbout, honk *Honk) {
	jonk, _ := jonkjonk(user, honk)
	jonk["@context"] = itiswhatitis
	var buf bytes.Buffer
	jonk.Write(&buf)
	msg := buf.Bytes()

	rcpts := make(map[string]bool)
	for _, a := range honk.Audience {
		if a != thewholeworld && a != user.URL && !strings.HasSuffix(a, "/followers") {
			box, _ := getboxes(a)
			if box != nil && honk.Public && box.Shared != "" {
				rcpts["%"+box.Shared] = true
			} else {
				rcpts[a] = true
			}
		}
	}
	if honk.Public {
		for _, f := range getdubs(user.ID) {
			box, _ := getboxes(f.XID)
			if box != nil && box.Shared != "" {
				rcpts["%"+box.Shared] = true
			} else {
				rcpts[f.XID] = true
			}
		}
	}
	for a := range rcpts {
		go deliverate(0, user.Name, a, msg)
	}
}

func asjonker(user *WhatAbout) junk.Junk {
	about := obfusbreak(user.About)

	j := junk.New()
	j["@context"] = itiswhatitis
	j["id"] = user.URL
	j["type"] = "Person"
	j["inbox"] = user.URL + "/inbox"
	j["outbox"] = user.URL + "/outbox"
	j["followers"] = user.URL + "/followers"
	j["following"] = user.URL + "/following"
	j["name"] = user.Display
	j["preferredUsername"] = user.Name
	j["summary"] = about
	j["url"] = user.URL
	a := junk.New()
	a["type"] = "Image"
	a["mediaType"] = "image/png"
	a["url"] = fmt.Sprintf("https://%s/a?a=%s", serverName, url.QueryEscape(user.URL))
	j["icon"] = a
	k := junk.New()
	k["id"] = user.URL + "#key"
	k["owner"] = user.URL
	k["publicKeyPem"] = user.Key
	j["publicKey"] = k

	return j
}

var handfull = make(map[string]string)
var handlock sync.Mutex

func gofish(name string) string {
	if name[0] == '@' {
		name = name[1:]
	}
	m := strings.Split(name, "@")
	if len(m) != 2 {
		log.Printf("bad fish name: %s", name)
		return ""
	}
	handlock.Lock()
	ref, ok := handfull[name]
	handlock.Unlock()
	if ok {
		return ref
	}
	row := stmtGetXonker.QueryRow(name, "fishname")
	var href string
	err := row.Scan(&href)
	if err == nil {
		handlock.Lock()
		handfull[name] = href
		handlock.Unlock()
		return href
	}
	log.Printf("fishing for %s", name)
	j, err := GetJunkFast(fmt.Sprintf("https://%s/.well-known/webfinger?resource=acct:%s", m[1], name))
	if err != nil {
		log.Printf("failed to go fish %s: %s", name, err)
		handlock.Lock()
		handfull[name] = ""
		handlock.Unlock()
		return ""
	}
	links, _ := j.GetArray("links")
	for _, li := range links {
		l, ok := li.(junk.Junk)
		if !ok {
			continue
		}
		href, _ := l.GetString("href")
		rel, _ := l.GetString("rel")
		t, _ := l.GetString("type")
		if rel == "self" && friendorfoe(t) {
			_, err := stmtSaveXonker.Exec(name, href, "fishname")
			if err != nil {
				log.Printf("error saving fishname: %s", err)
			}
			handlock.Lock()
			handfull[name] = href
			handlock.Unlock()
			return href
		}
	}
	handlock.Lock()
	handfull[name] = ""
	handlock.Unlock()
	return ""
}

func isactor(t string) bool {
	switch t {
	case "Person":
	case "Organization":
	case "Application":
	case "Service":
	default:
		return false
	}
	return true
}

func investigate(name string) *Honker {
	if name == "" {
		return nil
	}
	if name[0] == '@' {
		name = gofish(name)
	}
	if name == "" {
		return nil
	}
	log.Printf("digging up some info on %s", name)
	obj, err := GetJunkFast(name)
	if err != nil {
		log.Printf("error investigating honker: %s", err)
		return nil
	}
	t, _ := obj.GetString("type")
	if !isactor(t) {
		log.Printf("it's not a person! %s", name)
		return nil
	}
	xid, _ := obj.GetString("id")
	handle, _ := obj.GetString("preferredUsername")
	return &Honker{XID: xid, Handle: handle}
}