haven/hpcu/main.go

// hpcu unifies the PRIMARY and CLIPBOARD X11 selections for text contents.
package main

import (
	"errors"
	"janouch.name/haven/nexgb"
	"janouch.name/haven/nexgb/xfixes"
	"janouch.name/haven/nexgb/xproto"
	"log"
)

type selectionState struct {
	name       string           // name of the selection
	inProgress xproto.Timestamp // timestamp of retrieved selection
	buffer     []byte           // UTF-8 text buffer
	incr       bool             // INCR running
	incrFailed bool             // INCR failure indicator
	owning     xproto.Timestamp // since when we own the selection
}

var (
	X      *nexgb.Conn
	setup  *xproto.SetupInfo
	screen *xproto.ScreenInfo

	atomCLIPBOARD  xproto.Atom // X11 atom for CLIPBOARD
	atomUTF8String xproto.Atom // X11 atom for UTF8_STRING
	atomINCR       xproto.Atom // X11 atom for INCR
	atomTARGETS    xproto.Atom // X11 atom for TARGETS
	atomTIMESTAMP  xproto.Atom // X11 atom for TIMESTAMP

	wid        xproto.Window // auxiliary window
	selections map[xproto.Atom]*selectionState
	contents   string // current shared selection contents
)

// resolveAtoms resolves a few required atoms that are not in the core protocol.
func resolveAtoms() error {
	for _, i := range []struct {
		placement *xproto.Atom
		name      string
	}{
		{&atomCLIPBOARD, "CLIPBOARD"},
		{&atomUTF8String, "UTF8_STRING"},
		{&atomINCR, "INCR"},
		{&atomTARGETS, "TARGETS"},
		{&atomTIMESTAMP, "TIMESTAMP"},
	} {
		if reply, err := xproto.InternAtom(X,
			false, uint16(len(i.name)), i.name).Reply(); err != nil {
			return err
		} else {
			*i.placement = reply.Atom
		}
	}
	return nil
}

// setupAuxiliaryWindow creates a window that receives notifications about
// changed selection contents, and serves
func setupAuxiliaryWindow() error {
	var err error
	if wid, err = xproto.NewWindowId(X); err != nil {
		return err
	}

	_ = xproto.CreateWindow(X, screen.RootDepth, wid, screen.Root, 0, 0, 1, 1,
		0, xproto.WindowClassInputOutput, screen.RootVisual, xproto.CwEventMask,
		[]uint32{xproto.EventMaskPropertyChange})

	for _, selection := range []xproto.Atom{xproto.AtomPrimary, atomCLIPBOARD} {
		_ = xfixes.SelectSelectionInput(X, wid, selection,
			xfixes.SelectionEventMaskSetSelectionOwner|
				xfixes.SelectionEventMaskSelectionWindowDestroy|
				xfixes.SelectionEventMaskSelectionClientClose)
	}
	return nil
}

// getProperty reads a window property in a memory-efficient manner.
func getProperty(window xproto.Window, property xproto.Atom) (
	*xproto.GetPropertyReply, error) {
	// xorg-xserver doesn't seem to limit the length of replies or even
	// the length of properties in the first place. It only has a huge
	// (0xffffffff - sizeof(xChangePropertyReq))/4 limit for ChangeProperty
	// requests, even though I can't XChangeProperty more than 0xffffe0
	// bytes at a time.
	//
	// Since the XGB API doesn't let us provide our own buffer for
	// value data, let us avoid multiplying the amount of consumed memory in
	// pathological cases where properties are several gigabytes in size by
	// chunking the requests. This has a cost of losing atomicity, although
	// it shouldn't pose a problem except for timeout-caused INCR races.
	var result xproto.GetPropertyReply
	for result.Length == 0 || result.BytesAfter > 0 {
		reply, err := xproto.GetProperty(X, false, /* delete */
			window, property, xproto.GetPropertyTypeAny,
			uint32(len(result.Value))/4,
			uint32(setup.MaximumRequestLength)).Reply()
		if err != nil {
			return nil, err
		}
		if result.Length != 0 &&
			(reply.Format != result.Format || reply.Type != result.Type) {
			return nil, errors.New("property type changed during read")
		}

		reply.Value = append(result.Value, reply.Value...)
		reply.ValueLen += result.ValueLen
		result = *reply
	}
	return &result, nil
}

// appendText tries to append UTF-8 text to the selection state buffer.
func appendText(state *selectionState, prop *xproto.GetPropertyReply) bool {
	if prop.Type == atomUTF8String && prop.Format == 8 {
		state.buffer = append(state.buffer, prop.Value...)
		return true
	}
	return false
}

func requestOwnership(origin *selectionState, time xproto.Timestamp) {
	contents = string(origin.buffer)
	for selection, state := range selections {
		// We might want to replace the originator as well but it might have
		// undesirable effects, mainly with PRIMARY.
		if state != origin {
			// No need to GetSelectionOwner, XFIXES is more reliable.
			_ = xproto.SetSelectionOwner(X, wid, selection, time)
		}
	}
}

func handleXfixesSelectionNotify(e xfixes.SelectionNotifyEvent) {
	state, ok := selections[e.Selection]
	if !ok {
		return
	}

	// Ownership request has been granted, don't ask ourselves for data.
	if e.Owner == wid {
		state.owning = e.SelectionTimestamp
		return
	}

	// This should always be true.
	if state.owning < e.SelectionTimestamp {
		state.owning = 0
	}

	// Not checking whether we should give up when our current retrieval
	// attempt is interrupted--the timeout mostly solves this.
	if e.Owner == xproto.WindowNone {
		return
	}

	// Don't try to process two things at once. Each request gets a few
	// seconds to finish, then we move on, hoping that a property race
	// doesn't commence. Ideally we'd set up a separate queue for these
	// skipped requests and process them later.
	if state.inProgress != 0 && e.Timestamp-state.inProgress < 5000 {
		return
	}

	// ICCCM says we should ensure the named property doesn't exist.
	_ = xproto.DeleteProperty(X, e.Window, e.Selection)

	_ = xproto.ConvertSelection(X, e.Window, e.Selection,
		atomUTF8String, e.Selection, e.Timestamp)

	state.inProgress = e.Timestamp
	state.incr = false
}

func handleSelectionNotify(e xproto.SelectionNotifyEvent) {
	state, ok := selections[e.Selection]
	if e.Requestor != wid || !ok || e.Time != state.inProgress {
		return
	}

	state.inProgress = 0
	if e.Property == xproto.AtomNone {
		return
	}

	state.buffer = nil
	reply, err := getProperty(e.Requestor, e.Property)
	if err != nil {
		return
	}

	// When you select a lot of text in VIM, it starts the ICCCM
	// INCR mechanism, from which there is no opt-out.
	if reply.Type == atomINCR {
		state.inProgress = e.Time
		state.incr = true
		state.incrFailed = false
	} else if appendText(state, reply) {
		requestOwnership(state, e.Time)
	}

	_ = xproto.DeleteProperty(X, e.Requestor, e.Property)
}

func handlePropertyNotify(e xproto.PropertyNotifyEvent) {
	state, ok := selections[e.Atom]
	if e.Window != wid || e.State != xproto.PropertyNewValue ||
		!ok || !state.incr {
		return
	}

	reply, err := getProperty(e.Window, e.Atom)
	if err != nil {
		state.incrFailed = true
		return
	}

	if !appendText(state, reply) {
		// We need to keep deleting the property.
		state.incrFailed = true
	}

	if reply.ValueLen == 0 {
		if !state.incrFailed {
			requestOwnership(state, e.Time)
		}
		state.inProgress = 0
		state.incr = false
	}

	_ = xproto.DeleteProperty(X, e.Window, e.Atom)

}

func handleSelectionRequest(e xproto.SelectionRequestEvent) {
	property := e.Property
	if property == xproto.AtomNone {
		property = e.Target
	}

	state, ok := selections[e.Selection]
	if e.Owner != wid || !ok {
		return
	}

	var (
		typ    xproto.Atom
		format byte
		data   []byte
	)

	// XXX: We should also support the MULTIPLE target but it seems to be
	// unimportant and largely abandoned today.
	targets := []xproto.Atom{atomTARGETS, atomTIMESTAMP, atomUTF8String}

	switch e.Target {
	case atomTARGETS:
		typ = xproto.AtomAtom
		format = 32

		data = make([]byte, len(targets)*4)
		for i, atom := range targets {
			nexgb.Put32(data[i*4:], uint32(atom))
		}

	case atomTIMESTAMP:
		typ = xproto.AtomInteger
		format = 32

		data = make([]byte, 4)
		nexgb.Put32(data, uint32(state.owning))

	case atomUTF8String:
		typ = atomUTF8String
		format = 8

		data = []byte(contents)
	}

	response := xproto.SelectionNotifyEvent{
		Time:      e.Time,
		Requestor: e.Requestor,
		Selection: e.Selection,
		Target:    e.Target,
		Property:  xproto.AtomNone,
	}

	if typ == 0 || len(data) > int(setup.MaximumRequestLength)*4-64 ||
		state.owning == 0 || e.Time < state.owning {
		// TODO: Use the INCR mechanism for large data transfers instead
		// of refusing the request, or at least use PropModeAppend.
		//
		// According to the ICCCM we need to set up a queue for concurrent
		// (requestor, selection, target, timestamp) requests that differ
		// only in the target property, and process them in order. The ICCCM
		// has a nice rationale. It seems to only concern INCR. The queue
		// might be a map[(who, what, how, when)][](where, data, offset).
		//
		// NOTE: Even with BigRequests support, it may technically be
		// missing on the particular X server, and XGB copies buffers to yet
		// another buffer, making very large transfers a very bad idea.
	} else if xproto.ChangePropertyChecked(X, xproto.PropModeReplace,
		e.Requestor, property, typ, format,
		uint32(len(data)/int(format/8)), data).Check() == nil {
		response.Property = property
	}

	_ = xproto.SendEvent(X, false /* propagate */, e.Requestor,
		0 /* event mask */, string(response.Bytes()))
}

func handleXEvent(ev nexgb.Event) {
	switch e := ev.(type) {
	case xfixes.SelectionNotifyEvent:
		handleXfixesSelectionNotify(e)
	case xproto.SelectionNotifyEvent:
		handleSelectionNotify(e)
	case xproto.PropertyNotifyEvent:
		handlePropertyNotify(e)
	case xproto.SelectionRequestEvent:
		handleSelectionRequest(e)
	}
}

func main() {
	var err error
	if X, err = nexgb.NewConn(); err != nil {
		log.Fatalln(err)
	}
	if err = xfixes.Init(X); err != nil {
		log.Fatalln(err)
	}

	// Enable the extension.
	_ = xfixes.QueryVersion(X, xfixes.MajorVersion, xfixes.MinorVersion)

	setup = xproto.Setup(X)
	screen = setup.DefaultScreen(X)

	if err = resolveAtoms(); err != nil {
		log.Fatalln(err)
	}
	if err = setupAuxiliaryWindow(); err != nil {
		log.Fatalln(err)
	}

	// Now that we have our atoms, we can initialize state.
	selections = map[xproto.Atom]*selectionState{
		xproto.AtomPrimary: {name: "PRIMARY"},
		atomCLIPBOARD:      {name: "CLIPBOARD"},
	}

	for {
		ev, xerr := X.WaitForEvent()
		if xerr != nil {
			log.Printf("Error: %s\n", xerr)
			return
		}
		if ev != nil {
			handleXEvent(ev)
		}
	}
}