Capture globals from wl_registry

go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/gdamore/tcell v1.1.5-0.20190724020331-84b54971b46c
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/kyoh86/xdg v1.0.0
+	github.com/pkg/errors v0.8.1
 	golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a
 )
 

go.sum

@@ -55,6 +55,7 @@ github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzp
 github.com/miolini/datacounter v0.0.0-20190724021726-aa48df3a02c1/go.mod h1:P6fDJzlxN+cWYR09KbE9/ta+Y6JofX9tAUhJpWkWPaM=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/riywo/loginshell v0.0.0-20190610082906-2ed199a032f6/go.mod h1:/PfPXh0EntGc3QAAyUaviy4S9tzy4Zp0e2ilq4voC6E=

protocol.go

@@ -0,0 +1,147 @@
+package main
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"net"
+
+	"golang.org/x/sys/unix"
+)
+
+type WaylandPacket struct {
+	ObjectId  uint32
+	Length    uint16
+	Opcode    uint16
+	Arguments []byte
+	Fds       []uintptr
+
+	buffer *bytes.Buffer
+}
+
+type WaylandGlobal struct {
+	Interface string
+	GlobalId  uint32
+	Version   uint32
+}
+
+type WaylandObject struct {
+	ObjectId  uint32
+	Interface string
+	// TODO: Add interface, if we know it
+}
+
+func ReadPacket(conn *net.UnixConn) (*WaylandPacket, error) {
+	var fds []uintptr
+	var buf [8]byte
+	control := make([]byte, 24)
+
+	n, oobn, _, _, err := conn.ReadMsgUnix(buf[:], control)
+	if err != nil {
+		return nil, err
+	}
+	if n != 8 {
+		return nil, errors.New("Unable to read message header")
+	}
+	if oobn > 0 {
+		if oobn > len(control) {
+			return nil, errors.New("Control message buffer undersized")
+		}
+
+		ctrl, err := unix.ParseSocketControlMessage(control)
+		if err != nil {
+			return nil, err
+		}
+		for _, msg := range ctrl {
+			_fds, err := unix.ParseUnixRights(&msg)
+			if err != nil {
+				return nil, errors.New("Unable to parse unix rights")
+			}
+			if len(_fds) != 1 {
+				return nil, errors.New("Unexpectedly got >1 file descriptor")
+			}
+			fds = append(fds, uintptr(_fds[0]))
+		}
+	}
+
+	packet := &WaylandPacket{
+		ObjectId: binary.LittleEndian.Uint32(buf[0:4]),
+		Opcode:   binary.LittleEndian.Uint16(buf[4:6]),
+		Length:   binary.LittleEndian.Uint16(buf[6:8]),
+		Fds:      fds,
+	}
+
+	packet.Arguments = make([]byte, packet.Length - 8)
+
+	n, err = conn.Read(packet.Arguments)
+	if err != nil {
+		return nil, err
+	}
+	if int(packet.Length - 8) != len(packet.Arguments) {
+		return nil, errors.New("Buffer is shorter than expected length")
+	}
+
+	packet.Reset()
+	return packet, nil
+}
+
+func (packet WaylandPacket) WritePacket(conn *net.UnixConn) error {
+	var header bytes.Buffer
+	size := uint32(len(packet.Arguments) + 8)
+
+	binary.Write(&header, binary.LittleEndian, uint32(packet.ObjectId))
+	binary.Write(&header, binary.LittleEndian,
+		uint32(size<<16|uint32(packet.Opcode)&0x0000ffff))
+
+	var oob []byte
+	for _, fd := range packet.Fds {
+		rights := unix.UnixRights(int(fd))
+		oob = append(oob, rights...)
+	}
+
+	body := append(header.Bytes(), packet.Arguments...)
+	d, c, err := conn.WriteMsgUnix(body, oob, nil)
+	if err != nil {
+		return err
+	}
+	if c != len(oob) || d != len(body) {
+		return errors.New("WriteMsgUnix failed")
+	}
+
+	return nil
+}
+
+func (packet *WaylandPacket) Reset() {
+	packet.buffer = bytes.NewBuffer(packet.Arguments)
+}
+
+func szup(n uint32) uint32 {
+	if n % 4 == 0 {
+		return n
+	}
+	return n+(4-(n%4))
+}
+
+func (packet *WaylandPacket) ReadUint32() (uint32, error) {
+	var out uint32
+	err := binary.Read(packet.buffer, binary.LittleEndian, &out)
+	return out, err
+}
+
+func (packet *WaylandPacket) ReadString() (string, error) {
+	var l uint32
+	err := binary.Read(packet.buffer, binary.LittleEndian, &l)
+	if err != nil {
+		return "", err
+	}
+	var pl uint32 = szup(l)
+	buf := make([]byte, pl)
+	n, err := packet.buffer.Read(buf)
+	if err != nil {
+		return "", err
+	}
+	if n != int(pl) {
+		return "", errors.New("ReadString underread")
+	}
+	return string(buf[:l]), nil
+}