aboutsummaryrefslogtreecommitdiff
path: root/nexgb/xgb.go
diff options
context:
space:
mode:
Diffstat (limited to 'nexgb/xgb.go')
-rw-r--r--nexgb/xgb.go484
1 files changed, 484 insertions, 0 deletions
diff --git a/nexgb/xgb.go b/nexgb/xgb.go
new file mode 100644
index 0000000..7e209a7
--- /dev/null
+++ b/nexgb/xgb.go
@@ -0,0 +1,484 @@
+// Copyright 2009 The XGB Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The XGB package implements the X11 core protocol.
+// It is based on XCB: http://xcb.freedesktop.org/
+package xgb
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "net"
+ "os"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+const (
+ readBuffer = 100
+ writeBuffer = 100
+)
+
+// A Conn represents a connection to an X server.
+// Only one goroutine should use a Conn's methods at a time.
+type Conn struct {
+ host string
+ conn net.Conn
+ nextId Id
+ nextCookie uint16
+ cookies map[uint16]*Cookie
+ events queue
+ err error
+ display string
+ defaultScreen int
+ scratch [32]byte
+ Setup SetupInfo
+ extensions map[string]byte
+
+ requestChan chan *Request
+ requestCookieChan chan *Cookie
+ replyChan chan bool
+ eventChan chan bool
+ errorChan chan bool
+
+ newIdLock sync.Mutex
+ writeLock sync.Mutex
+ dequeueLock sync.Mutex
+ cookieLock sync.Mutex
+ extLock sync.Mutex
+}
+
+// Id is used for all X identifiers, such as windows, pixmaps, and GCs.
+type Id uint32
+
+// Request is used to abstract the difference between a request
+// that expects a reply and a request that doesn't expect a reply.
+type Request struct {
+ buf []byte
+ cookieChan chan *Cookie
+}
+
+func newRequest(buf []byte, needsReply bool) *Request {
+ req := &Request{
+ buf: buf,
+ cookieChan: nil,
+ }
+ if needsReply {
+ req.cookieChan = make(chan *Cookie)
+ }
+ return req
+}
+
+// Cookies are the sequence numbers used to pair replies up with their requests
+type Cookie struct {
+ id uint16
+ replyChan chan []byte
+ errorChan chan error
+}
+
+func newCookie(id uint16) *Cookie {
+ return &Cookie{
+ id: id,
+ replyChan: make(chan []byte, 1),
+ errorChan: make(chan error, 1),
+ }
+}
+
+// Event is an interface that can contain any of the events returned by the server.
+// Use a type assertion switch to extract the Event structs.
+type Event interface{}
+
+// Error contains protocol errors returned to us by the X server.
+type Error struct {
+ Detail uint8
+ Major uint8
+ Minor uint16
+ Cookie uint16
+ Id Id
+}
+
+func (e *Error) Error() string {
+ return fmt.Sprintf("Bad%s (major=%d minor=%d cookie=%d id=0x%x)",
+ errorNames[e.Detail], e.Major, e.Minor, e.Cookie, e.Id)
+}
+
+// NewID generates a new unused ID for use with requests like CreateWindow.
+func (c *Conn) NewId() Id {
+ c.newIdLock.Lock()
+ defer c.newIdLock.Unlock()
+
+ id := c.nextId
+ // TODO: handle ID overflow
+ c.nextId++
+ return id
+}
+
+// RegisterExtension adds the respective extension's major op code to
+// the extensions map.
+func (c *Conn) RegisterExtension(name string) error {
+ nameUpper := strings.ToUpper(name)
+ reply, err := c.QueryExtension(nameUpper)
+
+ switch {
+ case err != nil:
+ return err
+ case !reply.Present:
+ return errors.New(fmt.Sprintf("No extension named '%s' is present.",
+ nameUpper))
+ }
+
+ c.extLock.Lock()
+ c.extensions[nameUpper] = reply.MajorOpcode
+ c.extLock.Unlock()
+
+ return nil
+}
+
+// A simple queue used to stow away events.
+type queue struct {
+ data [][]byte
+ a, b int
+}
+
+func (q *queue) queue(item []byte) {
+ if q.b == len(q.data) {
+ if q.a > 0 {
+ copy(q.data, q.data[q.a:q.b])
+ q.a, q.b = 0, q.b-q.a
+ } else {
+ newData := make([][]byte, (len(q.data)*3)/2)
+ copy(newData, q.data)
+ q.data = newData
+ }
+ }
+ q.data[q.b] = item
+ q.b++
+}
+
+func (q *queue) dequeue(c *Conn) []byte {
+ c.dequeueLock.Lock()
+ defer c.dequeueLock.Unlock()
+
+ if q.a < q.b {
+ item := q.data[q.a]
+ q.a++
+ return item
+ }
+ return nil
+}
+
+// newWriteChan creates the channel required for writing to the net.Conn.
+func (c *Conn) newRequestChannels() {
+ c.requestChan = make(chan *Request, writeBuffer)
+ c.requestCookieChan = make(chan *Cookie, 1)
+
+ go func() {
+ for request := range c.requestChan {
+ cookieNum := c.nextCookie
+ c.nextCookie++
+
+ if request.cookieChan != nil {
+ cookie := newCookie(cookieNum)
+ c.cookies[cookieNum] = cookie
+ request.cookieChan <- cookie
+ }
+ if _, err := c.conn.Write(request.buf); err != nil {
+ fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err)
+ close(c.requestChan)
+ return
+ }
+ }
+ }()
+}
+
+// request is a buffered write to net.Conn.
+func (c *Conn) request(buf []byte, needsReply bool) *Cookie {
+ req := newRequest(buf, needsReply)
+ c.requestChan <- req
+
+ if req.cookieChan != nil {
+ cookie := <-req.cookieChan
+ close(req.cookieChan)
+ return cookie
+ }
+ return nil
+}
+
+func (c *Conn) sendRequest(needsReply bool, bufs ...[]byte) *Cookie {
+ if len(bufs) == 1 {
+ return c.request(bufs[0], needsReply)
+ }
+
+ total := make([]byte, 0)
+ for _, buf := range bufs {
+ total = append(total, buf...)
+ }
+ return c.request(total, needsReply)
+}
+
+func (c *Conn) newReadChannels() {
+ c.eventChan = make(chan bool, readBuffer)
+
+ onError := func() {
+ panic("read error")
+ }
+
+ go func() {
+ for {
+ buf := make([]byte, 32)
+ if _, err := io.ReadFull(c.conn, buf); err != nil {
+ fmt.Fprintf(os.Stderr, "x protocol read error: %s\n", err)
+ onError()
+ return
+ }
+
+ switch buf[0] {
+ case 0:
+ err := &Error{
+ Detail: buf[1],
+ Cookie: uint16(get16(buf[2:])),
+ Id: Id(get32(buf[4:])),
+ Minor: get16(buf[8:]),
+ Major: buf[10],
+ }
+ if cookie, ok := c.cookies[err.Cookie]; ok {
+ cookie.errorChan <- err
+ } else {
+ fmt.Fprintf(os.Stderr, "x protocol error: %s\n", err)
+ }
+ case 1:
+ seq := uint16(get16(buf[2:]))
+ if _, ok := c.cookies[seq]; !ok {
+ continue
+ }
+
+ size := get32(buf[4:])
+ if size > 0 {
+ bigbuf := make([]byte, 32+size*4, 32+size*4)
+ copy(bigbuf[0:32], buf)
+ if _, err := io.ReadFull(c.conn, bigbuf[32:]); err != nil {
+ fmt.Fprintf(os.Stderr,
+ "x protocol read error: %s\n", err)
+ onError()
+ return
+ }
+ c.cookies[seq].replyChan <- bigbuf
+ } else {
+ c.cookies[seq].replyChan <- buf
+ }
+ default:
+ c.events.queue(buf)
+ select {
+ case c.eventChan <- true:
+ default:
+ }
+ }
+ }
+ }()
+}
+
+func (c *Conn) waitForReply(cookie *Cookie) ([]byte, error) {
+ if cookie == nil {
+ panic("nil cookie")
+ }
+ if _, ok := c.cookies[cookie.id]; !ok {
+ panic("waiting for a cookie that will never come")
+ }
+ select {
+ case reply := <-cookie.replyChan:
+ return reply, nil
+ case err := <-cookie.errorChan:
+ return nil, err
+ }
+ panic("unreachable")
+}
+
+// WaitForEvent returns the next event from the server.
+// It will block until an event is available.
+func (c *Conn) WaitForEvent() (Event, error) {
+ for {
+ if reply := c.events.dequeue(c); reply != nil {
+ return parseEvent(reply)
+ }
+ if !<-c.eventChan {
+ return nil, errors.New("Event channel has been closed.")
+ }
+ }
+ panic("unreachable")
+}
+
+// PollForEvent returns the next event from the server if one is available in the internal queue.
+// It will not read from the connection, so you must call WaitForEvent to receive new events.
+// Only use this function to empty the queue without blocking.
+func (c *Conn) PollForEvent() (Event, error) {
+ if reply := c.events.dequeue(c); reply != nil {
+ return parseEvent(reply)
+ }
+ return nil, nil
+}
+
+// Dial connects to the X server given in the 'display' string.
+// If 'display' is empty it will be taken from os.Getenv("DISPLAY").
+//
+// Examples:
+// Dial(":1") // connect to net.Dial("unix", "", "/tmp/.X11-unix/X1")
+// Dial("/tmp/launch-123/:0") // connect to net.Dial("unix", "", "/tmp/launch-123/:0")
+// Dial("hostname:2.1") // connect to net.Dial("tcp", "", "hostname:6002")
+// Dial("tcp/hostname:1.0") // connect to net.Dial("tcp", "", "hostname:6001")
+func Dial(display string) (*Conn, error) {
+ c, err := connect(display)
+ if err != nil {
+ return nil, err
+ }
+
+ // Get authentication data
+ authName, authData, err := readAuthority(c.host, c.display)
+ noauth := false
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Could not get authority info: %v\n", err)
+ fmt.Fprintf(os.Stderr, "Trying connection without authority info...\n")
+ authName = ""
+ authData = []byte{}
+ noauth = true
+ }
+
+ // Assume that the authentication protocol is "MIT-MAGIC-COOKIE-1".
+ if !noauth && (authName != "MIT-MAGIC-COOKIE-1" || len(authData) != 16) {
+ return nil, errors.New("unsupported auth protocol " + authName)
+ }
+
+ buf := make([]byte, 12+pad(len(authName))+pad(len(authData)))
+ buf[0] = 0x6c
+ buf[1] = 0
+ put16(buf[2:], 11)
+ put16(buf[4:], 0)
+ put16(buf[6:], uint16(len(authName)))
+ put16(buf[8:], uint16(len(authData)))
+ put16(buf[10:], 0)
+ copy(buf[12:], []byte(authName))
+ copy(buf[12+pad(len(authName)):], authData)
+ if _, err = c.conn.Write(buf); err != nil {
+ return nil, err
+ }
+
+ head := make([]byte, 8)
+ if _, err = io.ReadFull(c.conn, head[0:8]); err != nil {
+ return nil, err
+ }
+ code := head[0]
+ reasonLen := head[1]
+ major := get16(head[2:])
+ minor := get16(head[4:])
+ dataLen := get16(head[6:])
+
+ if major != 11 || minor != 0 {
+ return nil, errors.New(fmt.Sprintf("x protocol version mismatch: %d.%d", major, minor))
+ }
+
+ buf = make([]byte, int(dataLen)*4+8, int(dataLen)*4+8)
+ copy(buf, head)
+ if _, err = io.ReadFull(c.conn, buf[8:]); err != nil {
+ return nil, err
+ }
+
+ if code == 0 {
+ reason := buf[8 : 8+reasonLen]
+ return nil, errors.New(fmt.Sprintf("x protocol authentication refused: %s", string(reason)))
+ }
+
+ getSetupInfo(buf, &c.Setup)
+
+ if c.defaultScreen >= len(c.Setup.Roots) {
+ c.defaultScreen = 0
+ }
+
+ c.nextId = Id(c.Setup.ResourceIdBase)
+ c.nextCookie = 1
+ c.cookies = make(map[uint16]*Cookie)
+ c.events = queue{make([][]byte, 100), 0, 0}
+ c.extensions = make(map[string]byte)
+
+ c.newReadChannels()
+ c.newRequestChannels()
+ return c, nil
+}
+
+// Close closes the connection to the X server.
+func (c *Conn) Close() { c.conn.Close() }
+
+func connect(display string) (*Conn, error) {
+ if len(display) == 0 {
+ display = os.Getenv("DISPLAY")
+ }
+
+ display0 := display
+ if len(display) == 0 {
+ return nil, errors.New("empty display string")
+ }
+
+ colonIdx := strings.LastIndex(display, ":")
+ if colonIdx < 0 {
+ return nil, errors.New("bad display string: " + display0)
+ }
+
+ var protocol, socket string
+ c := new(Conn)
+
+ if display[0] == '/' {
+ socket = display[0:colonIdx]
+ } else {
+ slashIdx := strings.LastIndex(display, "/")
+ if slashIdx >= 0 {
+ protocol = display[0:slashIdx]
+ c.host = display[slashIdx+1 : colonIdx]
+ } else {
+ c.host = display[0:colonIdx]
+ }
+ }
+
+ display = display[colonIdx+1 : len(display)]
+ if len(display) == 0 {
+ return nil, errors.New("bad display string: " + display0)
+ }
+
+ var scr string
+ dotIdx := strings.LastIndex(display, ".")
+ if dotIdx < 0 {
+ c.display = display[0:]
+ } else {
+ c.display = display[0:dotIdx]
+ scr = display[dotIdx+1:]
+ }
+
+ dispnum, err := strconv.Atoi(c.display)
+ if err != nil || dispnum < 0 {
+ return nil, errors.New("bad display string: " + display0)
+ }
+
+ if len(scr) != 0 {
+ c.defaultScreen, err = strconv.Atoi(scr)
+ if err != nil {
+ return nil, errors.New("bad display string: " + display0)
+ }
+ }
+
+ // Connect to server
+ if len(socket) != 0 {
+ c.conn, err = net.Dial("unix", socket+":"+c.display)
+ } else if len(c.host) != 0 {
+ if protocol == "" {
+ protocol = "tcp"
+ }
+ c.conn, err = net.Dial(protocol, c.host+":"+strconv.Itoa(6000+dispnum))
+ } else {
+ c.conn, err = net.Dial("unix", "/tmp/.X11-unix/X"+c.display)
+ }
+
+ if err != nil {
+ return nil, errors.New("cannot connect to " + display0 + ": " + err.Error())
+ }
+ return c, nil
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-22 14:02:03 +0000